package com.sg.service.biz.calc.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.calc.req.*;
import com.sg.dto.biz.calc.req.*;
import com.sg.dto.biz.calc.res.*;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerDetailComReqDto;
import com.sg.service.base.calc.MOmsStandardDataResultService;
import com.sg.service.biz.calc.*;
import com.wicket.okrapp.integration.*;
import com.wicket.okrapp.integration.dto.*;
import com.sg.common.exception.Assert;
import com.wicket.okrcalc.common.exception.BizException;
import com.wicket.okrcomponent.integration.*;
import com.wicket.okrcomponent.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class EvaCalcServiceImpl
        implements com.wicket.okrcalc.biz.service.EvaCalcService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsStandardDataResultService mOmsStandardDataResultService;
    @Resource
    private NbEvaCalc nbEvaCalc;
    @Resource
    private TargetCalcService fwAppTargetCalcClient;
    //@Resource
    //private undefinedService undefinedService;
//@Resource
    //private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private FwCompBusinessAtomClient fwCompBusinessAtomClient;
    @Resource
    private FwCompEvaCalcClient fwCompEvaCalcClient;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private TargetCycleService fwAppTargetCycleClient;
    @Resource
    private DivineDataService fwCompDivineDataClient;
    @Resource
    private DashboradStandardDataService dashboradStandardDataService;
    @Resource
    private FwAppExecuteCycleClient fwAppExecuteCycleClient;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private EvaCalcService fwAppEvaCalcClient;
    //@Resource
    //private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
//@Resource
    //private MCustomFields5Service mCustomFields5Service;
    @Resource
    private CalculationRulesService calculationRulesService;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private CycleStageDataService fwAppCycleStageDataClient;
    @Resource
    private TargetCalcService targetCalcService;
    @Resource
    private StandardDataService standardDataService;
    @Resource
    private DivineDataService divineDataService;

    /**
     * D4规划树执行计算公式(公共)[9684]
     * gen by moon at 5/30/2024, 11:10:53 PM
     */
    @Trace(operationName = "D4规划树执行计算公式(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementPlanTreeExecutesCalcFormulaComRespDto implementPlanTreeExecutesCalcFormulaCom(ImplementPlanTreeExecutesCalcFormulaComReqDto reqDto) {


        //步骤0: M4执行第九接收字段（特殊方法） - implementNineReceivingField
        //ModelCode: receptionService
        ImplementNineReceivingFieldRespDto receptionServiceRes = null;
        ImplementNineReceivingFieldReqDto receptionServiceReq = new ImplementNineReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1829331_1
            receptionServiceReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1829332_1
            receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1829323_1
            receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1829324_1
            receptionServiceReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1829335_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1829325_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1829326_1
        }

        /*M4接收入参字段[8708]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCycleStartTime(), "D4规划树执行计算公式(公共)-M4接收入参字段-周期开始时间不能为空", false);
        Assert.isNull(receptionServiceReq.getCycleEndTime(), "D4规划树执行计算公式(公共)-M4接收入参字段-周期结束时间不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjEntityId(), "D4规划树执行计算公式(公共)-M4接收入参字段-主树被评对象内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjTypeCode(), "D4规划树执行计算公式(公共)-M4接收入参字段-主树被评对象类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getBelongToContentId(), "D4规划树执行计算公式(公共)-M4接收入参字段-数据归属内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D4规划树执行计算公式(公共)-M4接收入参字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D4规划树执行计算公式(公共)-M4接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbEvaCalc.implementNineReceivingField(receptionServiceReq);


//步骤1: D3查询目标归属周期（双排序）列表(公共) - queryTargetBelongCycleBySortListCom
        QueryTargetBelongCycleBySortListComRespDto queryTargetBelongCycleBySortListComRespDto = null;
        QueryTargetBelongCycleBySortListComReqDto queryTargetBelongCycleBySortListComReqDto = new QueryTargetBelongCycleBySortListComReqDto();
        if (reqDto != null) {
            queryTargetBelongCycleBySortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1829130_1
            queryTargetBelongCycleBySortListComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1829131_1
            queryTargetBelongCycleBySortListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1829136_1
            queryTargetBelongCycleBySortListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1829135_1
            queryTargetBelongCycleBySortListComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1829137_1
            queryTargetBelongCycleBySortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1829132_1
            queryTargetBelongCycleBySortListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1829133_1
        }

        /*D3查询目标归属周期（双排序）列表(公共)[8733]   */
        Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getCycleStartTime(), "D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-周期开始时间不能为空", false);
        Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getCycleEndTime(), "D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-周期结束时间不能为空", false);
        Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getEvaObjEntityId(), "D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-主树被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getEvaObjTypeCode(), "D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-主树被评对象类型编码不能为空", false);
        Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getBelongToContentId(), "D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-数据归属内容表主键ID不能为空", false);
        Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getEvaluationTemplateId(), "D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(queryTargetBelongCycleBySortListComReqDto.getSpaceId(), "D4规划树执行计算公式(公共)-D3查询目标归属周期（双排序）列表(公共)-创建于空间ID不能为空", false);
        queryTargetBelongCycleBySortListComRespDto = fwAppTargetCalcClient.queryTargetBelongCycleBySortListCom(queryTargetBelongCycleBySortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        ImplementPlanTreeExecutesCalcFormulaComRespDto retData = new ImplementPlanTreeExecutesCalcFormulaComRespDto();


        return retData;
    }

    /**
     * D4执行分段查询目标父周期(公共)[9681]
     * gen by moon at 5/30/2024, 11:33:16 PM
     */
    @Trace(operationName = "D4执行分段查询目标父周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementSegQueryTargetCycleComRespDto implementSegQueryTargetCycleCom(ImplementSegQueryTargetCycleComReqDto reqDto) {


        //virtualUsage M4约定业务数据对象等  69378
        //ModelCode: receptionService
        ImplementNineReceivingFieldRespDto receptionServiceRes = null;
        ImplementNineReceivingFieldReqDto receptionServiceReq = new ImplementNineReceivingFieldReqDto();
        receptionServiceReq.setBusinessDataSetTableName("baa3c5a8375c11ed87d500163e1b729d");//CUSTOM_CONVENTION//sourceId:1829097_1_69378
        receptionServiceReq.setRedisDataObjectCatalogue("分段查询临时记录");//sourceId:1829098_1_69378

        /*M4约定业务数据对象等[8708]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getBusinessDataSetTableName(), "D4执行分段查询目标父周期(公共)-M4约定业务数据对象等-业务数据对象表名不能为空", false);
        Assert.isNull(receptionServiceReq.getRedisDataObjectCatalogue(), "D4执行分段查询目标父周期(公共)-M4约定业务数据对象等-Redis数据对象目录不能为空", false);
        receptionServiceRes = nbEvaCalc.implementNineReceivingField(receptionServiceReq);


//virtualUsage M4计算死循环（特殊方法）  69379
        //ModelCode: endlessLoop
        // TODO: 2024/5/31
        while (true) {


//virtualUsage D2查Redis中上一批次数据集最后一条记录（业务原子）  69380
            QueryRedisBusinessDataSetDetailComRespDto queryRedisBusinessDataSetDetailComRespDto = null;
            QueryRedisBusinessDataSetDetailComReqDto queryRedisBusinessDataSetDetailComReqDto = new QueryRedisBusinessDataSetDetailComReqDto();
            if (receptionServiceRes != null) {
                queryRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1829099_1_69380
                queryRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1829101_1_69380
            }
            if (reqDto != null) {
                queryRedisBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1829100_1_69380
            }

            /*D2查Redis中上一批次数据集最后一条记录（业务原子）[8411]   */
            Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D4执行分段查询目标父周期(公共)-D2查Redis中上一批次数据集最后一条记录（业务原子）-业务数据对象不能为空", false);
            Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D4执行分段查询目标父周期(公共)-D2查Redis中上一批次数据集最后一条记录（业务原子）-Redis数据对象目录不能为空", false);
            Assert.isNull(queryRedisBusinessDataSetDetailComReqDto.getDataObjectBatchCode(), "D4执行分段查询目标父周期(公共)-D2查Redis中上一批次数据集最后一条记录（业务原子）-数据对象批次标识不能为空", false);
            queryRedisBusinessDataSetDetailComRespDto = fwCompBusinessAtomClient.queryRedisBusinessDataSetDetailCom(queryRedisBusinessDataSetDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3分段查询目标内容目标周期(公共)  69381
            ImplementSubsectionQueryTargetContCycleComRespDto implementSubsectionQueryTargetContCycleComRespDto = null;
            if (queryRedisBusinessDataSetDetailComRespDto != null) {
                ImplementSubsectionQueryTargetContCycleComReqDto implementSubsectionQueryTargetContCycleComReqDto = new ImplementSubsectionQueryTargetContCycleComReqDto();
                implementSubsectionQueryTargetContCycleComReqDto.setDatasNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1827810_1_69381
                implementSubsectionQueryTargetContCycleComReqDto.setOrderFieldName("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:1827811_1_69381
                implementSubsectionQueryTargetContCycleComReqDto.setOrderRule("FROM_LARGE_TO_SMALL");//sourceId:1827812_1_69381
                implementSubsectionQueryTargetContCycleComReqDto.setBusinessDataSetPrimaryKeyName("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:1827813_1_69381
                implementSubsectionQueryTargetContCycleComReqDto.setIsParentCycle("TRUE");//CUSTOM_CONVENTION//sourceId:1829103_1_69381
                implementSubsectionQueryTargetContCycleComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//CUSTOM_CONVENTION//sourceId:1829104_1_69381
                if (receptionServiceRes != null) {
                    implementSubsectionQueryTargetContCycleComReqDto.setBusinessDataSetTableName(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1827809_1_69381
                }
                if (queryRedisBusinessDataSetDetailComRespDto != null) {
                    implementSubsectionQueryTargetContCycleComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1827814_1_69381
                }
                if (reqDto != null) {
                    implementSubsectionQueryTargetContCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1827815_1_69381
                    implementSubsectionQueryTargetContCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1827816_1_69381
                }

                /*D3分段查询目标内容目标周期(公共)[9663]   */
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getBusinessDataSetTableName(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-业务数据对象表名不能为空", false);
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getDatasNum(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-数据条数不能为空", false);
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getOrderFieldName(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-排序字段名不能为空", false);
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getOrderRule(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-排序规则不能为空", false);
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getBusinessDataSetPrimaryKeyName(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-业务数据对象主键名不能为空", false);
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getEvaObjEntityId(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-被评对象内容表主键ID不能为空", false);
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getEvaObjTypeCode(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-被评对象类型编码不能为空", false);
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getIsParentCycle(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-是否父周期不能为空", false);
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getEvaluationTemplateId(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-评价模板ID不能为空", false);
                Assert.isNull(implementSubsectionQueryTargetContCycleComReqDto.getSubjectLifeCycle(), "D4执行分段查询目标父周期(公共)-D3分段查询目标内容目标周期(公共)-主体生命周期不能为空", false);
                implementSubsectionQueryTargetContCycleComRespDto = fwAppTargetCalcClient.implementSubsectionQueryTargetContCycleCom(implementSubsectionQueryTargetContCycleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementSubsectionQueryTargetContCycleComRespDto != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList() != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList().size() > 0)) {
                //if(D3分段查询目标内容目标周期(公共).被评对象目标周期列表数据集条数 大于 0)  69382

                RefreshSegQueryRedisRecordComRespDto refreshSegQueryRedisRecordComRespDto = null;
                if (implementSubsectionQueryTargetContCycleComRespDto != null && queryRedisBusinessDataSetDetailComRespDto != null) {
                    RefreshSegQueryRedisRecordComReqDto refreshSegQueryRedisRecordComReqDto = new RefreshSegQueryRedisRecordComReqDto();
                    refreshSegQueryRedisRecordComReqDto.setBusinessDataSetPrimaryKeyName("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:1828720_1_69386
                    if (implementSubsectionQueryTargetContCycleComRespDto != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList() != null && !CollectionUtil.isEmpty(implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList())) {
                        refreshSegQueryRedisRecordComReqDto.setBusinessDataSetList(implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList().stream().map(item -> String.valueOf(item.getEvaObjTargetCycleId()))
                                .collect(Collectors.toList()));/*list-to-strings*///sourceId:1828715_1_69386
                    }
                    if (receptionServiceRes != null) {
                        refreshSegQueryRedisRecordComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1828716_1_69386
                        refreshSegQueryRedisRecordComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1828717_1_69386
                    }
                    if (reqDto != null) {
                        refreshSegQueryRedisRecordComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1828718_1_69386
                    }
                    if (queryRedisBusinessDataSetDetailComRespDto != null) {
                        refreshSegQueryRedisRecordComReqDto.setLastDataObjectId(queryRedisBusinessDataSetDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1828719_1_69386
                    }

                    /*D2更新分段查询Redis记录(公共)[9679]   */
                    Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataObject(), "D4执行分段查询目标父周期(公共)-D2更新分段查询Redis记录(公共)-业务数据对象不能为空", false);
                    Assert.isNull(refreshSegQueryRedisRecordComReqDto.getRedisDataObjectCatalogue(), "D4执行分段查询目标父周期(公共)-D2更新分段查询Redis记录(公共)-Redis数据对象目录不能为空", false);
                    Assert.isNull(refreshSegQueryRedisRecordComReqDto.getDataObjectBatchCode(), "D4执行分段查询目标父周期(公共)-D2更新分段查询Redis记录(公共)-数据对象批次标识不能为空", false);
                    Assert.isNull(refreshSegQueryRedisRecordComReqDto.getBusinessDataSetPrimaryKeyName(), "D4执行分段查询目标父周期(公共)-D2更新分段查询Redis记录(公共)-业务数据对象主键名不能为空", false);
                    refreshSegQueryRedisRecordComRespDto = fwCompEvaCalcClient.refreshSegQueryRedisRecordCom(refreshSegQueryRedisRecordComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//ModelCode: circulationCollections
                for (com.wicket.okrapp.integration.dto.EvaObjTargetCycleDto circulationCollectionsRes : implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList()) {

//ModelCode: circulationEnd
                }

            } else if ((implementSubsectionQueryTargetContCycleComRespDto != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList() != null && implementSubsectionQueryTargetContCycleComRespDto.getEvaObjTargetCycleList().size() == 0)) {
                //elseif(D3分段查询目标内容目标周期(公共).被评对象目标周期列表数据集条数 等于 0)  69383

                DeleteRedisBusinessDataComRespDto deleteRedisBusinessDataComRespDto = null;
                DeleteRedisBusinessDataComReqDto deleteRedisBusinessDataComReqDto = new DeleteRedisBusinessDataComReqDto();
                deleteRedisBusinessDataComReqDto.setIsDataList("FALSE");//sourceId:1828610_1_69384
                if (receptionServiceRes != null) {
                    deleteRedisBusinessDataComReqDto.setBusinessDataObject(receptionServiceRes.getBusinessDataSetTableName());//SimpleFieldAssign//sourceId:1828607_1_69384
                    deleteRedisBusinessDataComReqDto.setRedisDataObjectCatalogue(receptionServiceRes.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1828611_1_69384
                }
                if (reqDto != null) {
                    deleteRedisBusinessDataComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1828609_1_69384
                }

                /*D2-删除redis业务数据对象(公共)[8397]   */
                Assert.isNull(deleteRedisBusinessDataComReqDto.getBusinessDataObject(), "D4执行分段查询目标父周期(公共)-D2-删除redis业务数据对象(公共)-业务数据对象不能为空", false);
                Assert.isNull(deleteRedisBusinessDataComReqDto.getRedisDataObjectCatalogue(), "D4执行分段查询目标父周期(公共)-D2-删除redis业务数据对象(公共)-Redis数据对象目录不能为空", false);
                Assert.isNull(deleteRedisBusinessDataComReqDto.getDataObjectBatchCode(), "D4执行分段查询目标父周期(公共)-D2-删除redis业务数据对象(公共)-数据对象批次标识不能为空", false);
                Assert.isNull(deleteRedisBusinessDataComReqDto.getIsDataList(), "D4执行分段查询目标父周期(公共)-D2-删除redis业务数据对象(公共)-是否是数据集对象不能为空", false);
                deleteRedisBusinessDataComRespDto = interfaceModeService.deleteRedisBusinessDataCom(deleteRedisBusinessDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: end
                // TODO: 2024/5/31
                break;


            }
        }
        ImplementSegQueryTargetCycleComRespDto retData = new ImplementSegQueryTargetCycleComRespDto();


        return retData;
    }

    /**
     * D4查询标准数据(开始时间小于结束时间大于等于)详情[9804]
     * gen by moon at 6/14/2024, 6:49:23 PM
     */
    @Trace(operationName = "D4查询标准数据(开始时间小于结束时间大于等于)详情")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryStandardDataStartLessEndBigEqualDetailComRespDto queryStandardDataStartLessEndBigEqualDetailCom(QueryStandardDataStartLessEndBigEqualDetailComReqDto reqDto) {


        OmsStandardDataResult omsStandardDataResult_1 = null;
//步骤0: 4-1-01查询标准数据(开始时间小于结束时间大于等于)详情 - queryStandardDataStartLessEndBigEqualDetail
        OmsStandardDataResult omsStandardDataResult = null;
        QueryStandardDataStartLessEndBigEqualDetailReq queryStandardDataStartLessEndBigEqualDetailReq = new QueryStandardDataStartLessEndBigEqualDetailReq();
        if (reqDto != null) {
            queryStandardDataStartLessEndBigEqualDetailReq.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1865538_1
            queryStandardDataStartLessEndBigEqualDetailReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1865541_1
            queryStandardDataStartLessEndBigEqualDetailReq.setIsNewData(reqDto.getIsNewData());//SimpleFieldAssign//sourceId:1865542_1
            queryStandardDataStartLessEndBigEqualDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1865539_1
            queryStandardDataStartLessEndBigEqualDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1865540_1
            queryStandardDataStartLessEndBigEqualDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1865544_1
            queryStandardDataStartLessEndBigEqualDetailReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1865545_1
            queryStandardDataStartLessEndBigEqualDetailReq.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1865543_1
            queryStandardDataStartLessEndBigEqualDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1865546_1
            queryStandardDataStartLessEndBigEqualDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1865547_1
        }

        /*4-1-01查询标准数据(开始时间小于结束时间大于等于)详情[9803]   */
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getDataType(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-数据点类型不能为空", false);
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getParentSubMidCycleType(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-父子中周期类型不能为空", false);
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getIsNewData(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-是否归属周期最新数据不能为空", false);
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getCycleStartTime(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-周期开始时间不能为空", false);
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getCycleEndTime(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-周期结束时间不能为空", false);
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getCycleTypeCode(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-周期类型标识不能为空", false);
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getBelongToContentId(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-数据归属内容表主键ID不能为空", false);
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getExtendedField3(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-扩展字段3不能为空", false);
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getThemeContentId(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-主题内容ID不能为空", false);
        Assert.isNull(queryStandardDataStartLessEndBigEqualDetailReq.getSubjectLifeCycle(), "D4查询标准数据(开始时间小于结束时间大于等于)详情-4-1-01查询标准数据(开始时间小于结束时间大于等于)详情-主体生命周期不能为空", false);
        omsStandardDataResult = mOmsStandardDataResultService.queryStandardDataStartLessEndBigEqualDetail(queryStandardDataStartLessEndBigEqualDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsStandardDataResult_1 = omsStandardDataResult;

        QueryStandardDataStartLessEndBigEqualDetailComRespDto retData = new QueryStandardDataStartLessEndBigEqualDetailComRespDto();
        if (omsStandardDataResult_1 != null) {
            retData.setDataResultId(omsStandardDataResult_1.getDataResultId());//SimpleFieldAssign//sourceId:1865560_1
            retData.setDataResult(omsStandardDataResult_1.getDataResult());//SimpleFieldAssign//sourceId:1865561_1
        }


        return retData;
    }

    /**
     * D4分析历史与当前工作周期标准数据(公共)[9848]
     * gen by moon at 6/23/2024, 9:04:18 PM
     */
    @Trace(operationName = "D4分析历史与当前工作周期标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisHistoryAndCurWorkCycleStandDardComRespDto analysisHistoryAndCurWorkCycleStandDardCom(AnalysisHistoryAndCurWorkCycleStandDardComReqDto reqDto) {


        //virtualUsage M4约定当前系统时间  70615
        //ModelCode: receptionService
        ImplementCalcReceivingField003RespDto receptionServiceRes = null;
        ImplementCalcReceivingField003ReqDto receptionServiceReq = new ImplementCalcReceivingField003ReqDto();
        receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1887224_1_70615

        /*M4约定当前系统时间[9537]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getComTimeField(), "D4分析历史与当前工作周期标准数据(公共)-M4约定当前系统时间-通用时间字段不能为空", false);
        receptionServiceRes = nbEvaCalc.implementCalcReceivingField003(receptionServiceReq);


//virtualUsage D2-3查配置项匹配答案详情(公共)（跨服务）  70708
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1889475_1_70708
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("CYCLE_MODE");//CUSTOM_CONVENTION//sourceId:1889476_1_70708
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1889477_1_70708
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1889474_1_70708
        }

        /*D2-3查配置项匹配答案详情(公共)（跨服务）[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D4分析历史与当前工作周期标准数据(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D4分析历史与当前工作周期标准数据(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D4分析历史与当前工作周期标准数据(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D4分析历史与当前工作周期标准数据(公共)-D2-3查配置项匹配答案详情(公共)（跨服务）-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）  70612
        QueryEvaObjTargetCycleByCycleTimeListComRespDto queryEvaObjTargetCycleByCycleTimeListComRespDto = null;
        QueryEvaObjTargetCycleByCycleTimeListComReqDto queryEvaObjTargetCycleByCycleTimeListComReqDto = new QueryEvaObjTargetCycleByCycleTimeListComReqDto();
        queryEvaObjTargetCycleByCycleTimeListComReqDto.setTargetCycleContentTypeCode("TARGET");//sourceId:1889422_1_70612
        queryEvaObjTargetCycleByCycleTimeListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1887218_1_70612
        if (reqDto != null) {
            queryEvaObjTargetCycleByCycleTimeListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1887215_1_70612
            queryEvaObjTargetCycleByCycleTimeListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1887216_1_70612
            queryEvaObjTargetCycleByCycleTimeListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887217_1_70612
        }

        /*D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）[7720]   */
        Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getEvaObjEntityId(), "D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getEvaObjTypeCode(), "D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-被评对象类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getTargetCycleContentTypeCode(), "D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-关联目标内容类型编码不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getEvaluationTemplateId(), "D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleByCycleTimeListComReqDto.getSubjectLifeCycle(), "D4分析历史与当前工作周期标准数据(公共)-D3查当前评价模板的被评对象目标周期列表（工作周期列表范围）-主体生命周期不能为空", false);
        queryEvaObjTargetCycleByCycleTimeListComRespDto = fwAppTargetCycleClient.queryEvaObjTargetCycleByCycleTimeListCom(queryEvaObjTargetCycleByCycleTimeListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage M4-执行目标周期循环开始【特殊方法】  70613
        //ModelCode: circulationCollections
        for (com.wicket.okrapp.integration.dto.EvaObjTargetCycleDto circulationCollectionsRes : queryEvaObjTargetCycleByCycleTimeListComRespDto.getEvaObjTargetCycleList()) {

//virtualUsage D3分析目标父子中周期类型(公共)  70707
            AnalysisTargetParentSubMidCycleTypeComRespDto analysisTargetParentSubMidCycleTypeComRespDto = null;
            if (queryConfItemMatchAnswerDetailComRespDto != null) {
                AnalysisTargetParentSubMidCycleTypeComReqDto analysisTargetParentSubMidCycleTypeComReqDto = new AnalysisTargetParentSubMidCycleTypeComReqDto();
                if (queryConfItemMatchAnswerDetailComRespDto != null) {
                    analysisTargetParentSubMidCycleTypeComReqDto.setPeriodicModeTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1889443_1_70707
                }
                if (circulationCollectionsRes != null) {
                    analysisTargetParentSubMidCycleTypeComReqDto.setIsParentCycle(circulationCollectionsRes.getIsParentCycle() != null ? String.valueOf(circulationCollectionsRes.getIsParentCycle()) : "");//SimpleFieldAssign//sourceId:1889445_1_70707
                    analysisTargetParentSubMidCycleTypeComReqDto.setIsMetaphase(circulationCollectionsRes.getIsMetaphase() != null ? String.valueOf(circulationCollectionsRes.getIsMetaphase()) : "");//SimpleFieldAssign//sourceId:1889446_1_70707
                    analysisTargetParentSubMidCycleTypeComReqDto.setIsSubCycle(circulationCollectionsRes.getIsSubCycle() != null ? String.valueOf(circulationCollectionsRes.getIsSubCycle()) : "");//SimpleFieldAssign//sourceId:1889444_1_70707
                }

                /*D3分析目标父子中周期类型(公共)[9842]   */
                Assert.isNull(analysisTargetParentSubMidCycleTypeComReqDto.getPeriodicModeTypeCode(), "D4分析历史与当前工作周期标准数据(公共)-D3分析目标父子中周期类型(公共)-周期模式类型编码不能为空", false);
                Assert.isNull(analysisTargetParentSubMidCycleTypeComReqDto.getIsParentCycle(), "D4分析历史与当前工作周期标准数据(公共)-D3分析目标父子中周期类型(公共)-是否父周期不能为空", false);
                Assert.isNull(analysisTargetParentSubMidCycleTypeComReqDto.getIsMetaphase(), "D4分析历史与当前工作周期标准数据(公共)-D3分析目标父子中周期类型(公共)-是否中期不能为空", false);
                Assert.isNull(analysisTargetParentSubMidCycleTypeComReqDto.getIsSubCycle(), "D4分析历史与当前工作周期标准数据(公共)-D3分析目标父子中周期类型(公共)-是否子周期不能为空", false);
                analysisTargetParentSubMidCycleTypeComRespDto = fwAppEvaCalcClient.analysisTargetParentSubMidCycleTypeCom(analysisTargetParentSubMidCycleTypeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
//virtualUsage D2两个时间对比大小(公共)  70621
            CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
            CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
            if (receptionServiceRes != null) {
                checkTimeScopeSearchComReqDto.setCurrentTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1887230_1_70621
            }
            if (circulationCollectionsRes != null) {
                checkTimeScopeSearchComReqDto.setCompareTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1887232_1_70621
            }

            /*D2两个时间对比大小(公共)[3297]   */
            Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D4分析历史与当前工作周期标准数据(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
            Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D4分析历史与当前工作周期标准数据(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
            checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))) {
                //if(D2当前系统时间与目标计划结束时间对比.时间比较结果 等于 之后（大于）)  70622

                ImplementUpdateCycleStatisticsDataComRespDto implementUpdateCycleStatisticsDataComRespDto = null;
                if (analysisTargetParentSubMidCycleTypeComRespDto != null) {
                    ImplementUpdateCycleStatisticsDataComReqDto implementUpdateCycleStatisticsDataComReqDto = new ImplementUpdateCycleStatisticsDataComReqDto();
                    implementUpdateCycleStatisticsDataComReqDto.setUpdateDataCycleSceneType("HISTORY_WORK_CYCLE");//sourceId:1887578_1_70665
                    if (reqDto != null) {
                        implementUpdateCycleStatisticsDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1889433_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1889434_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setIsForceStaticHistoryData(reqDto.getIsForceStaticHistoryData());//SimpleFieldAssign//sourceId:1887579_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887580_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887584_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setEvaluationTemplateTypeCode(reqDto.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:1889436_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1889437_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setHighestOrgID(reqDto.getHighestOrgID());//SimpleFieldAssign//sourceId:1889438_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1889439_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1889440_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:1889441_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1889442_1_70665
                    }
                    if (circulationCollectionsRes != null) {
                        implementUpdateCycleStatisticsDataComReqDto.setTargetCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1890035_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887583_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1887581_1_70665
                        implementUpdateCycleStatisticsDataComReqDto.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1887582_1_70665
                    }
                    if (analysisTargetParentSubMidCycleTypeComRespDto != null) {
                        implementUpdateCycleStatisticsDataComReqDto.setParentSubMidCycleType(analysisTargetParentSubMidCycleTypeComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1889435_1_70665
                    }

                    /*D4执行历史工作周期的统计数据(公共)[9853]   */
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getEventBatchUpdateCode(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-事务内数据更新批次标识不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getCalcStartTime(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-计算开始时间不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getUpdateDataCycleSceneType(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-数据更新周期场景类型不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getIsForceStaticHistoryData(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-是否强制统计历史数据不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getUpdateCycleTypeCode(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-更新周期类型标识不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getTargetCycleId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-目标周期ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getEvaObjTargetCycleId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-被评对象目标周期ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getParentSubMidCycleType(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-父子中过程周期类型不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getCycleStartTime(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-目标计划开始时间不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getCycleEndTime(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-目标计划结束时间不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getEvaluationTemplateId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getEvaluationTemplateTypeCode(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-冗余评价模板类型配置项不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getOperationInductionId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-操作人就职记录ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getHighestOrgID(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-最高组织ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getSpaceId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-创建于空间ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getAppId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-创建于联盟应用ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getDecimalPointRules(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-小数点规则不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto.getDecimalDigitsLastRules(), "D4分析历史与当前工作周期标准数据(公共)-D4执行历史工作周期的统计数据(公共)-小数最后一位规则不能为空", false);
                    implementUpdateCycleStatisticsDataComRespDto = dashboradStandardDataService.implementUpdateCycleStatisticsDataCom(implementUpdateCycleStatisticsDataComReqDto)/*vcase invoke isSameApp*/;


                }
            } else if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("BEFORE") || checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))) {
                //elseif((D2当前系统时间与目标计划结束时间对比.时间比较结果 等于 之前（小于） or D2当前系统时间与目标计划结束时间对比.时间比较结果 等于 当前（等于）))  70623

                ImplementUpdateCycleStatisticsDataComRespDto implementUpdateCycleStatisticsDataComRespDto_1 = null;
                if (analysisTargetParentSubMidCycleTypeComRespDto != null) {
                    ImplementUpdateCycleStatisticsDataComReqDto implementUpdateCycleStatisticsDataComReqDto_1 = new ImplementUpdateCycleStatisticsDataComReqDto();
                    implementUpdateCycleStatisticsDataComReqDto_1.setUpdateDataCycleSceneType("CUR_WORK_CYCLE");//sourceId:1887573_1_70667
                    if (reqDto != null) {
                        implementUpdateCycleStatisticsDataComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1889423_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1889424_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setIsForceStaticHistoryData(reqDto.getIsForceStaticHistoryData());//SimpleFieldAssign//sourceId:1887574_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887575_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887572_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setEvaluationTemplateTypeCode(reqDto.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:1889431_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1889425_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setHighestOrgID(reqDto.getHighestOrgID());//SimpleFieldAssign//sourceId:1889426_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1889427_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1889428_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:1889429_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1889430_1_70667
                    }
                    if (circulationCollectionsRes != null) {
                        implementUpdateCycleStatisticsDataComReqDto_1.setTargetCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1890088_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887571_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1887576_1_70667
                        implementUpdateCycleStatisticsDataComReqDto_1.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1887577_1_70667
                    }
                    if (analysisTargetParentSubMidCycleTypeComRespDto != null) {
                        implementUpdateCycleStatisticsDataComReqDto_1.setParentSubMidCycleType(analysisTargetParentSubMidCycleTypeComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1889432_1_70667
                    }

                    /*D4执行当前工作周期的统计数据(公共)[9853]   */
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getEventBatchUpdateCode(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-事务内数据更新批次标识不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getCalcStartTime(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-计算开始时间不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getUpdateDataCycleSceneType(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-数据更新周期场景类型不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getIsForceStaticHistoryData(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-是否强制统计历史数据不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getUpdateCycleTypeCode(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-更新周期类型标识不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getTargetCycleId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-目标周期ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getEvaObjTargetCycleId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-被评对象目标周期ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getParentSubMidCycleType(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-父子中过程周期类型不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getCycleStartTime(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-目标计划开始时间不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getCycleEndTime(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-目标计划结束时间不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getEvaluationTemplateId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getEvaluationTemplateTypeCode(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-冗余评价模板类型配置项不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getOperationInductionId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-操作人就职记录ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getHighestOrgID(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-最高组织ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getSpaceId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-创建于空间ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getAppId(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-创建于联盟应用ID不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getDecimalPointRules(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-小数点规则不能为空", false);
                    Assert.isNull(implementUpdateCycleStatisticsDataComReqDto_1.getDecimalDigitsLastRules(), "D4分析历史与当前工作周期标准数据(公共)-D4执行当前工作周期的统计数据(公共)-小数最后一位规则不能为空", false);
                    implementUpdateCycleStatisticsDataComRespDto_1 = dashboradStandardDataService.implementUpdateCycleStatisticsDataCom(implementUpdateCycleStatisticsDataComReqDto_1)/*vcase invoke isSameApp*/;


                }
            }
//virtualUsage M4-执行【循环结束】  70614
            //ModelCode: circulationEnd
        }

        AnalysisHistoryAndCurWorkCycleStandDardComRespDto retData = new AnalysisHistoryAndCurWorkCycleStandDardComRespDto();


        return retData;
    }

    /**
     * D4分析历史与当前更新周期(公共)[9849]
     * gen by moon at 9/15/2024, 11:26:36 PM
     */
    @Trace(operationName = "D4分析历史与当前更新周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisHistoryAndCurUpdateCycleComRespDto analysisHistoryAndCurUpdateCycleCom(AnalysisHistoryAndCurUpdateCycleComReqDto reqDto) {


        ImplementCalcReceivingField003RespDto receptionServiceRes_3 = null;
//virtualUsage M4约定系统当前时间  70626
        //ModelCode: receptionService
        ImplementCalcReceivingField003RespDto receptionServiceRes = null;
        ImplementCalcReceivingField003ReqDto receptionServiceReq = new ImplementCalcReceivingField003ReqDto();
        receptionServiceReq.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1887388_1_70626

        /*M4约定系统当前时间[9537]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getComTimeField(), "D4分析历史与当前更新周期(公共)-M4约定系统当前时间-通用时间字段不能为空", false);
        receptionServiceRes = nbEvaCalc.implementCalcReceivingField003(receptionServiceReq);


        if ((reqDto != null && reqDto.getUpdateDataCycleSceneType() != null && reqDto.getUpdateDataCycleSceneType().equals("HISTORY_WORK_CYCLE"))) {
            //if(D4分析历史与当前更新周期(公共).数据更新周期场景类型 等于 历史工作周期)  70628

            QueryExecuteCycleByEvaTempListComRespDto queryExecuteCycleByEvaTempListComRespDto = null;
            QueryExecuteCycleByEvaTempListComReqDto queryExecuteCycleByEvaTempListComReqDto = new QueryExecuteCycleByEvaTempListComReqDto();
            queryExecuteCycleByEvaTempListComReqDto.setRelateContentTypeCode("TARGET");//sourceId:1925277_1_70661
            queryExecuteCycleByEvaTempListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1887542_1_70661
            queryExecuteCycleByEvaTempListComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1887543_1_70661
            if (reqDto != null) {
                queryExecuteCycleByEvaTempListComReqDto.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887544_1_70661
                queryExecuteCycleByEvaTempListComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1887540_1_70661
                queryExecuteCycleByEvaTempListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887541_1_70661
            }

            /*D3查询执行周期阶段列表(公共)[9854]   */
            Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getCycleTypeCode(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表(公共)-周期类型标识不能为空", false);
            Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getRelateContentTypeCode(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表(公共)-关联目标内容类型编码不能为空", false);
            Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getSubjectLifeCycle(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表(公共)-主体生命周期不能为空", false);
            Assert.isNull(queryExecuteCycleByEvaTempListComReqDto.getSpaceId(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表(公共)-创建于空间ID不能为空", false);
            queryExecuteCycleByEvaTempListComRespDto = fwAppExecuteCycleClient.queryExecuteCycleByEvaTempListCom(queryExecuteCycleByEvaTempListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
            ImplementCalcReceivingField003RespDto receptionServiceRes_2 = null;
            if (queryExecuteCycleByEvaTempListComRespDto != null) {
                ImplementCalcReceivingField003ReqDto receptionServiceReq_1 = new ImplementCalcReceivingField003ReqDto();
                if (queryExecuteCycleByEvaTempListComRespDto != null && queryExecuteCycleByEvaTempListComRespDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(queryExecuteCycleByEvaTempListComRespDto.getExecuteCycleStageList())) {
                    receptionServiceReq_1.setUpdateCycleList(//objList-to-objLists
                            queryExecuteCycleByEvaTempListComRespDto.getExecuteCycleStageList().stream().map(item -> {
                                UpdateCycleDto elm = new UpdateCycleDto();
                                if (item != null) {
                                    elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:390864_2_70651
                                    elm.setUpdateCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:379010_2_70651
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887433_1_70651
                }

                /*M4接收出参：更新周期ID列表[9537]  用于特殊方法接收上游入参。 */

                receptionServiceRes_2 = nbEvaCalc.implementCalcReceivingField003(receptionServiceReq_1);


                receptionServiceRes_3 = receptionServiceRes_2;
            }
        } else if ((reqDto != null && reqDto.getUpdateDataCycleSceneType() != null && reqDto.getUpdateDataCycleSceneType().equals("CUR_WORK_CYCLE"))) {
            //elseif(D4分析历史与当前更新周期(公共).数据更新周期场景类型 等于 当前工作周期)  70639

            QueryExecuteCycleBigStartLessEndListComRespDto queryExecuteCycleBigStartLessEndListComRespDto = null;
            QueryExecuteCycleBigStartLessEndListComReqDto queryExecuteCycleBigStartLessEndListComReqDto = new QueryExecuteCycleBigStartLessEndListComReqDto();
            queryExecuteCycleBigStartLessEndListComReqDto.setRelateContentTypeCode("TARGET");//sourceId:1925280_1_70640
            queryExecuteCycleBigStartLessEndListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1889575_1_70640
            if (reqDto != null) {
                queryExecuteCycleBigStartLessEndListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1887312_1_70640
                queryExecuteCycleBigStartLessEndListComReqDto.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887314_1_70640
                queryExecuteCycleBigStartLessEndListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887316_1_70640
            }
            if (receptionServiceRes != null) {
                queryExecuteCycleBigStartLessEndListComReqDto.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1887313_1_70640
            }

            /*D3查询执行周期阶段列表（开始大于等于&结束小于等于）[9850]   */
            Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getCycleStartTime(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空", false);
            Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getCycleEndTime(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空", false);
            Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getCycleTypeCode(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-周期类型标识不能为空", false);
            Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getRelateContentTypeCode(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-关联目标内容类型编码不能为空", false);
            Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getEvaluationTemplateId(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空", false);
            Assert.isNull(queryExecuteCycleBigStartLessEndListComReqDto.getSubjectLifeCycle(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始大于等于&结束小于等于）-主体生命周期不能为空", false);
            queryExecuteCycleBigStartLessEndListComRespDto = fwAppExecuteCycleClient.queryExecuteCycleBigStartLessEndListCom(queryExecuteCycleBigStartLessEndListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            QueryExecuteCycleLessStartBIgEndListComRespDto queryExecuteCycleLessStartBIgEndListComRespDto = null;
            QueryExecuteCycleLessStartBIgEndListComReqDto queryExecuteCycleLessStartBIgEndListComReqDto = new QueryExecuteCycleLessStartBIgEndListComReqDto();
            queryExecuteCycleLessStartBIgEndListComReqDto.setRelateContentTypeCode("TARGET");//sourceId:1925284_1_70646
            queryExecuteCycleLessStartBIgEndListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1887372_1_70646
            if (receptionServiceRes != null) {
                queryExecuteCycleLessStartBIgEndListComReqDto.setCycleStartTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1887369_1_70646
                queryExecuteCycleLessStartBIgEndListComReqDto.setCycleEndTime(receptionServiceRes.getComTimeField());//SimpleFieldAssign//sourceId:1887370_1_70646
            }
            if (reqDto != null) {
                queryExecuteCycleLessStartBIgEndListComReqDto.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1887436_1_70646
                queryExecuteCycleLessStartBIgEndListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887371_1_70646
            }

            /*D3查询执行周期阶段列表（开始小于等于&结束大于等于）[9851]   */
            Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getCycleStartTime(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-周期开始时间不能为空", false);
            Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getCycleEndTime(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-周期结束时间不能为空", false);
            Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getCycleTypeCode(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-周期类型标识不能为空", false);
            Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getRelateContentTypeCode(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-关联目标内容类型编码不能为空", false);
            Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getEvaluationTemplateId(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-评价模板ID不能为空", false);
            Assert.isNull(queryExecuteCycleLessStartBIgEndListComReqDto.getSubjectLifeCycle(), "D4分析历史与当前更新周期(公共)-D3查询执行周期阶段列表（开始小于等于&结束大于等于）-主体生命周期不能为空", false);
            queryExecuteCycleLessStartBIgEndListComRespDto = fwAppExecuteCycleClient.queryExecuteCycleLessStartBIgEndListCom(queryExecuteCycleLessStartBIgEndListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto = null;
            if (queryExecuteCycleBigStartLessEndListComRespDto != null && queryExecuteCycleLessStartBIgEndListComRespDto != null) {
                ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto = new ImplementUnionMultipleDataSetsComReqDto();
                if (queryExecuteCycleBigStartLessEndListComRespDto != null && queryExecuteCycleBigStartLessEndListComRespDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(queryExecuteCycleBigStartLessEndListComRespDto.getExecuteCycleStageList())) {
                    implementUnionMultipleDataSetsComReqDto.setDataSetsListOne(//objList-to-objLists
                            queryExecuteCycleBigStartLessEndListComRespDto.getExecuteCycleStageList().stream().map(item -> {
                                com.wicket.okrcomponent.integration.dto.DataSetsListOneDto elm = new com.wicket.okrcomponent.integration.dto.DataSetsListOneDto();
                                if (item != null) {
                                    elm.setCustomField(item.getCycleId());//SimpleFieldAssign//sourceId:378990_2_70658
                                    elm.setCustomField1(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:390868_2_70658
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887414_1_70658
                }
                if (queryExecuteCycleLessStartBIgEndListComRespDto != null && queryExecuteCycleLessStartBIgEndListComRespDto.getExecuteCycleStageList() != null && !CollectionUtil.isEmpty(queryExecuteCycleLessStartBIgEndListComRespDto.getExecuteCycleStageList())) {
                    implementUnionMultipleDataSetsComReqDto.setDataSetsListTwo(//objList-to-objLists
                            queryExecuteCycleLessStartBIgEndListComRespDto.getExecuteCycleStageList().stream().map(item -> {
                                com.wicket.okrcomponent.integration.dto.DataSetsListTwoDto elm = new com.wicket.okrcomponent.integration.dto.DataSetsListTwoDto();
                                if (item != null) {
                                    elm.setCustomField(item.getCycleId());//SimpleFieldAssign//sourceId:378995_2_70658
                                    elm.setCustomField1(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:390869_2_70658
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887415_1_70658
                }

                /*D2执行多数据集取并集(公共)[5320]   */

                implementUnionMultipleDataSetsComRespDto = interfaceModeService.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            ImplementManyFieldsDataSetDuplicateRemovalComRespDto implementManyFieldsDataSetDuplicateRemovalComRespDto = null;
            if (implementUnionMultipleDataSetsComRespDto != null) {
                ImplementManyFieldsDataSetDuplicateRemovalComReqDto implementManyFieldsDataSetDuplicateRemovalComReqDto = new ImplementManyFieldsDataSetDuplicateRemovalComReqDto();
                if (implementUnionMultipleDataSetsComRespDto != null && implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList() != null && !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList())) {
                    implementManyFieldsDataSetDuplicateRemovalComReqDto.setDataSetDuplicateRemovalList(//objList-to-objLists
                            implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList().stream().map(item -> {
                                DataSetDuplicateRemovalDto elm = new DataSetDuplicateRemovalDto();
                                if (item != null) {
                                    elm.setCommPrimaryKey(item.getCustomField1());//SimpleFieldAssign//sourceId:379001_2_70659
                                    elm.setCustomField1(item.getCustomField());//SimpleFieldAssign//sourceId:390871_2_70659
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887417_1_70659
                }

                /*D2执行多字段数据集记录去重(公共)[7323]   */

                implementManyFieldsDataSetDuplicateRemovalComRespDto = interfaceModeService.implementManyFieldsDataSetDuplicateRemovalCom(implementManyFieldsDataSetDuplicateRemovalComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
//ModelCode: receptionService
            ImplementCalcReceivingField003RespDto receptionServiceRes_4 = null;
            if (implementManyFieldsDataSetDuplicateRemovalComRespDto != null) {
                ImplementCalcReceivingField003ReqDto receptionServiceReq_2 = new ImplementCalcReceivingField003ReqDto();
                if (implementManyFieldsDataSetDuplicateRemovalComRespDto != null && implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList() != null && !CollectionUtil.isEmpty(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList())) {
                    receptionServiceReq_2.setUpdateCycleList(//objList-to-objLists
                            implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList().stream().map(item -> {
                                UpdateCycleDto elm = new UpdateCycleDto();
                                if (item != null) {
                                    elm.setExecuteCycleStageId(item.getCommPrimaryKey());//SimpleFieldAssign//sourceId:390864_2_70660
                                    elm.setUpdateCycleId(item.getCustomField1());//SimpleFieldAssign//sourceId:379010_2_70660
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887433_1_70660
                }

                /*M4接收出参：更新周期ID列表[9537]  用于特殊方法接收上游入参。 */

                receptionServiceRes_4 = nbEvaCalc.implementCalcReceivingField003(receptionServiceReq_2);


                receptionServiceRes_3 = receptionServiceRes_4;
            }
        }
        AnalysisHistoryAndCurUpdateCycleComRespDto retData = new AnalysisHistoryAndCurUpdateCycleComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setUpdateCycleList(receptionServiceRes_3.getUpdateCycleList().stream().map(item -> BeanUtil.toBean(item, UpdateCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887437_1
        }


        return retData;
    }

    /**
     * D4执行修正进度值/实际值/费用金额(公共)[9862]
     * gen by moon at 6/24/2024, 4:42:10 AM
     */
    @Trace(operationName = "D4执行修正进度值/实际值/费用金额(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAdjustedProgressActualCostAmountComRespDto implementAdjustedProgressActualCostAmountCom(ImplementAdjustedProgressActualCostAmountComReqDto reqDto) {


        ImplementCalcReceiveFieldRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getDataResultId() == null)) {
            //if(D4执行修正进度值/实际值/费用金额(公共).数据结果ID  值等于空 )  70754

//ModelCode: receptionService
            ImplementCalcReceiveFieldRespDto receptionServiceRes = null;
            ImplementCalcReceiveFieldReqDto receptionServiceReq = new ImplementCalcReceiveFieldReqDto();
            if (reqDto != null) {
                receptionServiceReq.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1891188_1_70756
                receptionServiceReq.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1891189_1_70756
                receptionServiceReq.setBudgetDisburse(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1891190_1_70756
            }

            /*M4接收进度值与实际值、预算支出金额出参[9725]  用于特殊方法接收上游入参。 */

            receptionServiceRes = nbEvaCalc.implementCalcReceiveField(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        } else if ((reqDto != null && reqDto.getDataResultId() != null)) {
            //elseif(D4执行修正进度值/实际值/费用金额(公共).数据结果ID  值不等于空 )  70755

//ModelCode: receptionService
            ImplementCalcReceiveFieldRespDto receptionServiceRes_2 = null;
            ImplementCalcReceiveFieldReqDto receptionServiceReq_1 = new ImplementCalcReceiveFieldReqDto();
            if (reqDto != null) {
                receptionServiceReq_1.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1891188_1_70757
                receptionServiceReq_1.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1891189_1_70757
            }

            /*M4接收进度值与实际值、预算支出金额出参[9725]  用于特殊方法接收上游入参。 */

            receptionServiceRes_2 = nbEvaCalc.implementCalcReceiveField(receptionServiceReq_1);


            receptionServiceRes_1 = receptionServiceRes_2;
        }
        ImplementAdjustedProgressActualCostAmountComRespDto retData = new ImplementAdjustedProgressActualCostAmountComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setProgressValue(receptionServiceRes_1.getProgressValue());//SimpleFieldAssign//sourceId:1891194_1
            retData.setActualValue(receptionServiceRes_1.getActualValue());//SimpleFieldAssign//sourceId:1891195_1
            retData.setBudgetDisburse(receptionServiceRes_1.getBudgetDisburse());//SimpleFieldAssign//sourceId:1891196_1
        }


        return retData;
    }

    /**
     * D4分析数据点计算场景(公共)[9863]
     * gen by moon at 6/24/2024, 4:42:22 AM
     */
    @Trace(operationName = "D4分析数据点计算场景(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisDataTypeCalcSceneComRespDto analysisDataTypeCalcSceneCom(AnalysisDataTypeCalcSceneComReqDto reqDto) {


        ImplementCalcReceiveFieldRespDto receptionServiceRes_3 = null;
//virtualUsage M4约定审核计算场景  70758
        //ModelCode: receptionService
        ImplementCalcReceiveFieldRespDto receptionServiceRes = null;
        ImplementCalcReceiveFieldReqDto receptionServiceReq = new ImplementCalcReceiveFieldReqDto();
        receptionServiceReq.setCustomField1("PLAN_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1891289_1_70758
        receptionServiceReq.setCustomField2("PLAN_FINACE_UPDATE");//CUSTOM_CONVENTION//sourceId:1891290_1_70758
        receptionServiceReq.setCustomField3("PLAN_TARGET_AND_FINACE_CALC");//CUSTOM_CONVENTION//sourceId:1891291_1_70758

        /*M4约定审核计算场景[9725]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D4分析数据点计算场景(公共)-M4约定审核计算场景-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D4分析数据点计算场景(公共)-M4约定审核计算场景-自定义字段2不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField3(), "D4分析数据点计算场景(公共)-M4约定审核计算场景-自定义字段3不能为空", false);
        receptionServiceRes = nbEvaCalc.implementCalcReceiveField(receptionServiceReq);


        if ((reqDto != null && reqDto.getProgressValue() != null || reqDto != null && reqDto.getActualValue() != null) && (reqDto != null && reqDto.getBudgetDisburse() == null)) {
            //if((D4分析计算的数据点(公共).进度值（数值） 值不等于空  or D4分析计算的数据点(公共).实际值（数值） 值不等于空 ) and D4分析计算的数据点(公共).预算支出金额 值等于空 )  70759

//ModelCode: receptionService
            ImplementCalcReceiveFieldRespDto receptionServiceRes_2 = null;
            ImplementCalcReceiveFieldReqDto receptionServiceReq_1 = new ImplementCalcReceiveFieldReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setApproveCalcScene(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1891340_1_70760
            }

            /*M4接收审核的计算场景出参[9725]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getApproveCalcScene(), "D4分析数据点计算场景(公共)-M4接收审核的计算场景出参-审核的计算场景不能为空", false);
            receptionServiceRes_2 = nbEvaCalc.implementCalcReceiveField(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getProgressValue() == null && reqDto != null && reqDto.getActualValue() == null && reqDto != null && reqDto.getBudgetDisburse() != null)) {
            //elseif((D4分析计算的数据点(公共).进度值（数值） 值等于空  and D4分析计算的数据点(公共).实际值（数值） 值等于空  and D4分析计算的数据点(公共).预算支出金额 值不等于空 ))  70761

//ModelCode: receptionService
            ImplementCalcReceiveFieldRespDto receptionServiceRes_4 = null;
            ImplementCalcReceiveFieldReqDto receptionServiceReq_2 = new ImplementCalcReceiveFieldReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_2.setApproveCalcScene(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1891340_1_70762
            }

            /*M4接收审核的计算场景出参[9725]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getApproveCalcScene(), "D4分析数据点计算场景(公共)-M4接收审核的计算场景出参-审核的计算场景不能为空", false);
            receptionServiceRes_4 = nbEvaCalc.implementCalcReceiveField(receptionServiceReq_2);


            receptionServiceRes_3 = receptionServiceRes_4;
        } else if ((reqDto != null && reqDto.getProgressValue() != null || reqDto != null && reqDto.getActualValue() != null) && (reqDto != null && reqDto.getBudgetDisburse() != null)) {
            //elseif((D4分析计算的数据点(公共).进度值（数值） 值不等于空  or D4分析计算的数据点(公共).实际值（数值） 值不等于空 ) and D4分析计算的数据点(公共).预算支出金额 值不等于空 )  70763

//ModelCode: receptionService
            ImplementCalcReceiveFieldRespDto receptionServiceRes_5 = null;
            ImplementCalcReceiveFieldReqDto receptionServiceReq_3 = new ImplementCalcReceiveFieldReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_3.setApproveCalcScene(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1891340_1_70764
            }

            /*M4接收审核的计算场景出参[9725]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getApproveCalcScene(), "D4分析数据点计算场景(公共)-M4接收审核的计算场景出参-审核的计算场景不能为空", false);
            receptionServiceRes_5 = nbEvaCalc.implementCalcReceiveField(receptionServiceReq_3);


            receptionServiceRes_3 = receptionServiceRes_5;
        }
        AnalysisDataTypeCalcSceneComRespDto retData = new AnalysisDataTypeCalcSceneComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setApproveCalcScene(receptionServiceRes_3.getApproveCalcScene());//SimpleFieldAssign//sourceId:1891342_1
        }


        return retData;
    }

    /**
     * D4执行检测汇报进度值(公共)[9885]
     * gen by moon at 6/28/2024, 2:14:10 AM
     */
    @Trace(operationName = "D4执行检测汇报进度值(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCheckReportProgressValueComRespDto implementCheckReportProgressValueCom(ImplementCheckReportProgressValueComReqDto reqDto) {


        if ((reqDto != null && reqDto.getLastEvaObjTargetCycleId() != null && reqDto != null && reqDto.getPreviousCycleId() != null && reqDto != null && reqDto.getProgressValue() != null && reqDto != null && reqDto.getIsLastCycle() != null && reqDto.getIsLastCycle().equals("TRUE"))) {
            //if((D4执行检测汇报进度值(公共).上一被评对象目标周期ID 值不等于空  and D4执行检测汇报进度值(公共).上一归属周期ID 值不等于空  and D4执行检测汇报进度值(公共).进度值（数值） 值不等于空  and D4执行检测汇报进度值(公共).是否末级周期 等于 是))  71047

            OmsStandardDataResult omsStandardDataResult = null;
            QueryStandardDataDetailReq queryStandardDataDetailReq = new QueryStandardDataDetailReq();
            queryStandardDataDetailReq.setDataType("PROGRESS_VALUE");//sourceId:1904595_1_71052
            queryStandardDataDetailReq.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1904596_1_71052
            if (reqDto != null) {
                queryStandardDataDetailReq.setEntityId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1904600_1_71052
                queryStandardDataDetailReq.setPeriodId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1904598_1_71052
                queryStandardDataDetailReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1904599_1_71052
                queryStandardDataDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1904601_1_71052
            }

            /*4-01-01根据目标周期查上一个汇报周期的进度值标准数据[2696]   */
            Assert.isNull(queryStandardDataDetailReq.getDataType(), "D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-数据点类型不能为空", false);
            Assert.isNull(queryStandardDataDetailReq.getDataUsageSceneCode(), "D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-数据业务场景不能为空", false);
            Assert.isNull(queryStandardDataDetailReq.getEntityId(), "D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-归属内容表主键ID不能为空", false);
            Assert.isNull(queryStandardDataDetailReq.getPeriodId(), "D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-周期ID不能为空", false);
            Assert.isNull(queryStandardDataDetailReq.getParentSubMidCycleType(), "D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-父子中周期类型不能为空", false);
            Assert.isNull(queryStandardDataDetailReq.getThemeContentId(), "D4执行检测汇报进度值(公共)-4-01-01根据目标周期查上一个汇报周期的进度值标准数据-主题内容ID不能为空", false);
            omsStandardDataResult = mOmsStandardDataResultService.queryStandardDataDetail(queryStandardDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto = null;
            if (omsStandardDataResult != null) {
                ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto = new ImplementNumericalContrastMagnitudeComReqDto();
                if (reqDto != null) {
                    implementNumericalContrastMagnitudeComReqDto.setCalcPara1(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1904602_1_71053
                }
                if (omsStandardDataResult != null) {
                    implementNumericalContrastMagnitudeComReqDto.setCalcPara2(omsStandardDataResult.getDataResult());//SimpleFieldAssign//sourceId:1904603_1_71053
                }

                /*D2执行两个数值对比大小(公共)[5551]   */
                Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara1(), "D4执行检测汇报进度值(公共)-D2执行两个数值对比大小(公共)-计算入参1不能为空", false);
                Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara2(), "D4执行检测汇报进度值(公共)-D2执行两个数值对比大小(公共)-计算入参2不能为空", false);
                implementNumericalContrastMagnitudeComRespDto = interfaceModeService.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementNumericalContrastMagnitudeComRespDto != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("BEFORE"))) {
                //if(D2本次汇报进度值与上一个汇报周期进度值对比.数值比较结果 等于 之前（小于）)  71054

//异常结束 71056
                throw new BizException("3300220400474", "对不起，您输入的进度值低于上一次汇报，请重新输入~", false);
            }
        }
        ImplementCheckReportProgressValueComRespDto retData = new ImplementCheckReportProgressValueComRespDto();


        return retData;
    }

    /**
     * D4分析增财务父子中类型(公共)[9913]
     * gen by moon at 7/2/2024, 3:53:18 AM
     */
    @Trace(operationName = "D4分析增财务父子中类型(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisAddFinaceParentSubMidCycleTypeComRespDto analysisAddFinaceParentSubMidCycleTypeCom(AnalysisAddFinaceParentSubMidCycleTypeComReqDto reqDto) {


        ImplementCalcReceivingField002RespDto receptionServiceRes_3 = null;
//virtualUsage M4约定父子中周期类型及父或子或中周期类型  71194
        //ModelCode: receptionService
        ImplementCalcReceivingField002RespDto receptionServiceRes = null;
        ImplementCalcReceivingField002ReqDto receptionServiceReq = new ImplementCalcReceivingField002ReqDto();
        receptionServiceReq.setCustomField1("PARENT_CYCLE");//CUSTOM_CONVENTION//sourceId:1914661_1_71194
        receptionServiceReq.setCustomField2("SUB_CYCLE");//CUSTOM_CONVENTION//sourceId:1914662_1_71194
        receptionServiceReq.setParentCycleType("PARENT_CYCLE");//sourceId:1914674_1_71194
        receptionServiceReq.setMidCycleType("MID_CYCLE");//sourceId:1914675_1_71194
        receptionServiceReq.setSubCycleType("SUB_CYCLE");//sourceId:1914676_1_71194

        /*M4约定父子中周期类型及父或子或中周期类型[9536]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-自定义字段2不能为空", false);
        Assert.isNull(receptionServiceReq.getParentCycleType(), "D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-父周期类型不能为空", false);
        Assert.isNull(receptionServiceReq.getMidCycleType(), "D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-中周期类型不能为空", false);
        Assert.isNull(receptionServiceReq.getSubCycleType(), "D4分析增财务父子中类型(公共)-M4约定父子中周期类型及父或子或中周期类型-子周期类型不能为空", false);
        receptionServiceRes = nbEvaCalc.implementCalcReceivingField002(receptionServiceReq);


        if ((reqDto != null && reqDto.getCycleMode() != null && reqDto.getCycleMode().equals("SINGLE_CYCLE") || reqDto != null && reqDto.getCycleMode() != null && reqDto.getCycleMode().equals("IRREGULAR_CYCLE"))) {
            //if((D4分析增财务父子中类型(公共).周期模式 等于 单周期 or D4分析增财务父子中类型(公共).周期模式 等于 不规则周期))  71192

//ModelCode: receptionService
            ImplementCalcReceivingField002RespDto receptionServiceRes_2 = null;
            ImplementCalcReceivingField002ReqDto receptionServiceReq_1 = new ImplementCalcReceivingField002ReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1914682_1_71195
                receptionServiceReq_1.setParentCycleType(receptionServiceRes.getParentCycleType());//SimpleFieldAssign//sourceId:1914683_1_71195
            }

            /*M4接收父子中周期类型出参[9536]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getParentSubMidCycleType(), "D4分析增财务父子中类型(公共)-M4接收父子中周期类型出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_2 = nbEvaCalc.implementCalcReceivingField002(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getCycleMode() != null && reqDto.getCycleMode().equals("FATHER_SON_CYCLE"))) {
            //elseif(D4分析增财务父子中类型(公共).周期模式 等于 父子周期)  71193

//ModelCode: receptionService
            ImplementCalcReceivingField002RespDto receptionServiceRes_4 = null;
            ImplementCalcReceivingField002ReqDto receptionServiceReq_2 = new ImplementCalcReceivingField002ReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_2.setParentSubMidCycleType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1914682_1_71196
                receptionServiceReq_2.setSubCycleType(receptionServiceRes.getSubCycleType());//SimpleFieldAssign//sourceId:1914684_1_71196
            }

            /*M4接收父子中周期类型出参[9536]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getParentSubMidCycleType(), "D4分析增财务父子中类型(公共)-M4接收父子中周期类型出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_4 = nbEvaCalc.implementCalcReceivingField002(receptionServiceReq_2);


            receptionServiceRes_3 = receptionServiceRes_4;
        }
        AnalysisAddFinaceParentSubMidCycleTypeComRespDto retData = new AnalysisAddFinaceParentSubMidCycleTypeComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setParentSubMidCycleType(receptionServiceRes_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1914691_1
            retData.setParentCycleType(receptionServiceRes_3.getParentCycleType());//SimpleFieldAssign//sourceId:1914692_1
            retData.setMidCycleType(receptionServiceRes_3.getMidCycleType());//SimpleFieldAssign//sourceId:1914693_1
            retData.setSubCycleType(receptionServiceRes_3.getSubCycleType());//SimpleFieldAssign//sourceId:1914694_1
        }


        return retData;
    }

    /**
     * D4查询被评对象目标周期详情(跨)[9915]
     * gen by moon at 7/2/2024, 1:39:18 PM
     */
    @Trace(operationName = "D4查询被评对象目标周期详情(跨)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryEvaObjTargetCycleOverDetailComRespDto queryEvaObjTargetCycleOverDetailCom(QueryEvaObjTargetCycleOverDetailComReqDto reqDto) {


        QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto_1 = null;
//步骤0: D3-查询被评对象目标周期平台详情(公共) - queryEvaObjTargetCyclePlatformDetailCom
        QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
        QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto = new QueryEvaObjTargetCyclePlatformDetailComReqDto();
        if (reqDto != null) {
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1915684_1
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1915483_1
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1915485_1
            queryEvaObjTargetCyclePlatformDetailComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1915488_1
            queryEvaObjTargetCyclePlatformDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1915490_1
            queryEvaObjTargetCyclePlatformDetailComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1915496_1
            queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1915497_1
            queryEvaObjTargetCyclePlatformDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1915498_1
        }

        /*D3-查询被评对象目标周期平台详情(公共)[8528]   */
        Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(), "D4查询被评对象目标周期详情(跨)-D3-查询被评对象目标周期平台详情(公共)-冗余评价模板ID不能为空", false);
        queryEvaObjTargetCyclePlatformDetailComRespDto = fwAppTargetCycleClient.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryEvaObjTargetCyclePlatformDetailComRespDto_1 = queryEvaObjTargetCyclePlatformDetailComRespDto;

        QueryEvaObjTargetCycleOverDetailComRespDto retData = new QueryEvaObjTargetCycleOverDetailComRespDto();
        if (queryEvaObjTargetCyclePlatformDetailComRespDto_1 != null) {
            retData.setEvaObjTargetCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1915558_1
            retData.setEvaObjTargetCycleCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1915559_1
            retData.setParentEvaObjTargetCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1915560_1
            retData.setTargetCycleName(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetCycleName());//SimpleFieldAssign//sourceId:1915561_1
            retData.setCyclelAlias(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCyclelAlias());//SimpleFieldAssign//sourceId:1915562_1
            retData.setEvaluationObjectId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationObjectId());//SimpleFieldAssign//sourceId:1915563_1
            retData.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1915564_1
            retData.setEvaObjTableTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:1915565_1
            retData.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1915566_1
            retData.setTreeTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTreeTypeCode());//SimpleFieldAssign//sourceId:1915567_1
            retData.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1915568_1
            retData.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1915569_1
            retData.setIsUseFirstDept(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsUseFirstDept());//SimpleFieldAssign//sourceId:1915570_1
            retData.setIndicatorKind(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIndicatorKind());//SimpleFieldAssign//sourceId:1915571_1
            retData.setIsCustomObjective(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsCustomObjective());//SimpleFieldAssign//sourceId:1915572_1
            retData.setCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleId());//SimpleFieldAssign//sourceId:1915573_1
            retData.setCycleStandardName(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1915574_1
            retData.setIsParentCycle(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsParentCycle());//SimpleFieldAssign//sourceId:1915575_1
            retData.setIsMetaphase(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsMetaphase());//SimpleFieldAssign//sourceId:1915576_1
            retData.setIsSubCycle(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getIsSubCycle());//SimpleFieldAssign//sourceId:1915577_1
            retData.setCycleStartTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1915578_1
            retData.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1915579_1
            retData.setCycleTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1915580_1
            retData.setCycleTypeInstanceCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1915581_1
            retData.setCycleNumberShortName(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleNumberShortName());//SimpleFieldAssign//sourceId:1915582_1
            retData.setHaveProcessCycle(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getHaveProcessCycle());//SimpleFieldAssign//sourceId:1915583_1
            retData.setTargetReached(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetReached());//SimpleFieldAssign//sourceId:1915584_1
            retData.setTaskStatus(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTaskStatus());//SimpleFieldAssign//sourceId:1915585_1
            retData.setBizSceneCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getBizSceneCode());//SimpleFieldAssign//sourceId:1915586_1
            retData.setEvaluationSubjectTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationSubjectTypeCode());//SimpleFieldAssign//sourceId:1915587_1
            retData.setPlanningType(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getPlanningType());//SimpleFieldAssign//sourceId:1915588_1
            retData.setEvaluationTemplateTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationTemplateTypeCode());//SimpleFieldAssign//sourceId:1915589_1
            retData.setTargetId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetId());//SimpleFieldAssign//sourceId:1915590_1
            retData.setEvaluationTemplateId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1915591_1
            retData.setEvaluationSubjectId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1915592_1
            retData.setTargetTreeOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getTargetTreeOrderNumber());//SimpleFieldAssign//sourceId:1915593_1
            retData.setOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getOrderNumber());//SimpleFieldAssign//sourceId:1915594_1
            retData.setDutyBodyOrderNum(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getDutyBodyOrderNum());//SimpleFieldAssign//sourceId:1915595_1
            retData.setRelativeOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getRelativeOrderNumber());//SimpleFieldAssign//sourceId:1915596_1
            retData.setPersonalOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getPersonalOrderNumber());//SimpleFieldAssign//sourceId:1915597_1
            retData.setWeightOrderNumber(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getWeightOrderNumber());//SimpleFieldAssign//sourceId:1915598_1
            retData.setSortCreateTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getSortCreateTime());//SimpleFieldAssign//sourceId:1915599_1
            retData.setBatchCode(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getBatchCode());//SimpleFieldAssign//sourceId:1915600_1
            retData.setOperationInductionId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getOperationInductionId());//SimpleFieldAssign//sourceId:1915601_1
            retData.setCreateInductionId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCreateInductionId());//SimpleFieldAssign//sourceId:1915602_1
            retData.setReleaseInductionId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getReleaseInductionId());//SimpleFieldAssign//sourceId:1915603_1
            retData.setSpaceId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getSpaceId());//SimpleFieldAssign//sourceId:1915604_1
            retData.setAppId(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getAppId());//SimpleFieldAssign//sourceId:1915605_1
        }


        return retData;
    }

    /**
     * D4计算因子达成度转得分(公共)[9947]
     * gen by moon at 7/16/2024, 4:52:50 PM
     */
    @Trace(operationName = "D4计算因子达成度转得分(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CalculateFactorReachToScoreComRespDto calculateFactorReachToScoreCom(CalculateFactorReachToScoreComReqDto reqDto) {


        ImplementCalcReceivingField006RespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getReach() != null)) {
            //if(D4计算因子达成度转得分(公共).达成度 值不等于空 )  71608

            CalculateDivisionOfTwoNumComRespDto calculateDivisionOfTwoNumComRespDto = null;
            CalculateDivisionOfTwoNumComReqDto calculateDivisionOfTwoNumComReqDto = new CalculateDivisionOfTwoNumComReqDto();
            calculateDivisionOfTwoNumComReqDto.setCalcPara2(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:1925405_1_71609
            calculateDivisionOfTwoNumComReqDto.setDecimalPointRules(Long.valueOf(10));//CUSTOM_CONVENTION//sourceId:1925407_1_71609
            calculateDivisionOfTwoNumComReqDto.setDecimalDigitsLastRules("MALING");//sourceId:1925408_1_71609
            if (reqDto != null) {
                calculateDivisionOfTwoNumComReqDto.setCalcPara1(reqDto.getReach());//SimpleFieldAssign//sourceId:1925404_1_71609
            }

            /*D4达成度/100[4841]   */
            Assert.isNull(calculateDivisionOfTwoNumComReqDto.getCalcPara1(), "D4计算因子达成度转得分(公共)-D4达成度/100-计算入参1不能为空", false);
            Assert.isNull(calculateDivisionOfTwoNumComReqDto.getCalcPara2(), "D4计算因子达成度转得分(公共)-D4达成度/100-计算入参2不能为空", false);
            Assert.isNull(calculateDivisionOfTwoNumComReqDto.getDecimalPointRules(), "D4计算因子达成度转得分(公共)-D4达成度/100-小数点规则不能为空", false);
            Assert.isNull(calculateDivisionOfTwoNumComReqDto.getDecimalDigitsLastRules(), "D4计算因子达成度转得分(公共)-D4达成度/100-小数最后一位规则不能为空", false);
            calculateDivisionOfTwoNumComRespDto = calculationRulesService.calculateDivisionOfTwoNumCom(calculateDivisionOfTwoNumComReqDto)/*vcase invoke isSameApp*/;


            CalculateMultiplyTwoValuesComRespDto calculateMultiplyTwoValuesComRespDto = null;
            if (calculateDivisionOfTwoNumComRespDto != null) {
                CalculateMultiplyTwoValuesComReqDto calculateMultiplyTwoValuesComReqDto = new CalculateMultiplyTwoValuesComReqDto();
                calculateMultiplyTwoValuesComReqDto.setDecimalPointRules(Long.valueOf(10));//CUSTOM_CONVENTION//sourceId:1925412_1_71610
                calculateMultiplyTwoValuesComReqDto.setDecimalDigitsLastRules("MALING");//sourceId:1925413_1_71610
                if (calculateDivisionOfTwoNumComRespDto != null) {
                    calculateMultiplyTwoValuesComReqDto.setComFloatField1(calculateDivisionOfTwoNumComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1925409_1_71610
                }
                if (reqDto != null) {
                    calculateMultiplyTwoValuesComReqDto.setComFloatField2(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1925410_1_71610
                }

                /*D4目标得分=达成度/10*权重分[5443]   */
                Assert.isNull(calculateMultiplyTwoValuesComReqDto.getComFloatField1(), "D4计算因子达成度转得分(公共)-D4目标得分=达成度/10*权重分-通用数值字段1（小数型）不能为空", false);
                Assert.isNull(calculateMultiplyTwoValuesComReqDto.getComFloatField2(), "D4计算因子达成度转得分(公共)-D4目标得分=达成度/10*权重分-通用数值字段2（小数型）不能为空", false);
                Assert.isNull(calculateMultiplyTwoValuesComReqDto.getDecimalPointRules(), "D4计算因子达成度转得分(公共)-D4目标得分=达成度/10*权重分-小数点规则不能为空", false);
                Assert.isNull(calculateMultiplyTwoValuesComReqDto.getDecimalDigitsLastRules(), "D4计算因子达成度转得分(公共)-D4目标得分=达成度/10*权重分-小数最后一位规则不能为空", false);
                calculateMultiplyTwoValuesComRespDto = interfaceModeService.calculateMultiplyTwoValuesCom(calculateMultiplyTwoValuesComReqDto)/*vcase invoke isSameApp*/;


            }
            //ModelCode: receptionService
            ImplementCalcReceivingField006RespDto receptionServiceRes = null;
            if (calculateMultiplyTwoValuesComRespDto != null) {
                ImplementCalcReceivingField006ReqDto receptionServiceReq = new ImplementCalcReceivingField006ReqDto();
                if (calculateMultiplyTwoValuesComRespDto != null) {
                    receptionServiceReq.setTargetScore(calculateMultiplyTwoValuesComRespDto.getCalcResult());//SimpleFieldAssign//sourceId:1925476_1_71611
                }

                /*M4接收目标得分[9540]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getTargetScore(), "D4计算因子达成度转得分(公共)-M4接收目标得分-目标得分不能为空", false);
                receptionServiceRes = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }


        }

        CalculateFactorReachToScoreComRespDto retData = new CalculateFactorReachToScoreComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setTargetScore(receptionServiceRes_1.getTargetScore());//SimpleFieldAssign//sourceId:1925484_1
        }


        return retData;
    }

    /**
     * D4执行修正填报标准数据是否最新(公共)[9958]
     * gen by moon at 7/14/2024, 7:12:30 PM
     */
    @Trace(operationName = "D4执行修正填报标准数据是否最新(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAdjustedFillInStandardDataIsNewestComRespDto implementAdjustedFillInStandardDataIsNewestCom(ImplementAdjustedFillInStandardDataIsNewestComReqDto reqDto) {


        if ((reqDto != null && reqDto.getProgressValue() != null || reqDto != null && reqDto.getActualValue() != null) || (reqDto != null && reqDto.getDataResultId() != null && reqDto != null && reqDto.getBudgetDisburse() != null)) {
            //if((D4执行修正填报标准数据是否最新(公共).进度值（数值） 值不等于空  or D4执行修正填报标准数据是否最新(公共).实际值（数值） 值不等于空 ) or (D4执行修正填报标准数据是否最新(公共).数据结果ID  值不等于空  and D4执行修正填报标准数据是否最新(公共).预算支出金额 值不等于空 ))  71573

            ObtainTargetBelongCycleComRespDto obtainTargetBelongCycleComRespDto = null;
            ObtainTargetBelongCycleComReqDto obtainTargetBelongCycleComReqDto = new ObtainTargetBelongCycleComReqDto();
            if (reqDto != null) {
                obtainTargetBelongCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1931929_1_71574
                obtainTargetBelongCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1931930_1_71574
                obtainTargetBelongCycleComReqDto.setPreviousCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1931931_1_71574
                obtainTargetBelongCycleComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1932020_1_71574
                obtainTargetBelongCycleComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1931932_1_71574
                obtainTargetBelongCycleComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1931933_1_71574
                obtainTargetBelongCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1931934_1_71574
            }

            /*D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)[8739]   */
            Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaObjEntityId(), "D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-主树被评对象内容表主键ID不能为空", false);
            Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaObjTypeCode(), "D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-主树被评对象类型编码不能为空", false);
            Assert.isNull(obtainTargetBelongCycleComReqDto.getPreviousCycleId(), "D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-上一归属周期ID不能为空", false);
            Assert.isNull(obtainTargetBelongCycleComReqDto.getParentSubMidCycleType(), "D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-父子中过程周期类型不能为空", false);
            Assert.isNull(obtainTargetBelongCycleComReqDto.getEntityId(), "D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-归属内容表主键ID不能为空", false);
            Assert.isNull(obtainTargetBelongCycleComReqDto.getEvaluationTemplateId(), "D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-冗余评价模板ID不能为空", false);
            Assert.isNull(obtainTargetBelongCycleComReqDto.getSpaceId(), "D4执行修正填报标准数据是否最新(公共)-D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期)-创建于空间ID不能为空", false);
            obtainTargetBelongCycleComRespDto = fwAppTargetCalcClient.obtainTargetBelongCycleCom(obtainTargetBelongCycleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((obtainTargetBelongCycleComRespDto != null && obtainTargetBelongCycleComRespDto.getFromContentEntityId() != null)) {
                //if(D3入参当前周期查上一目标归属周期(用于判断当前周期是否最新周期).来自内容表主键ID 值不等于空 )  71575

                QueryCycleStageDataDetailComRespDto queryCycleStageDataDetailComRespDto = null;
                if (obtainTargetBelongCycleComRespDto != null) {
                    QueryCycleStageDataDetailComReqDto queryCycleStageDataDetailComReqDto = new QueryCycleStageDataDetailComReqDto();
                    if (obtainTargetBelongCycleComRespDto != null) {
                        queryCycleStageDataDetailComReqDto.setCycleStageDataId(obtainTargetBelongCycleComRespDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1932071_1_71578
                    }
                    if (reqDto != null) {
                        queryCycleStageDataDetailComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1932072_1_71578
                        queryCycleStageDataDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1932073_1_71578
                    }

                    /*D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交)[3962]   */
                    Assert.isNull(queryCycleStageDataDetailComReqDto.getCycleStageDataId(), "D4执行修正填报标准数据是否最新(公共)-D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交)-周期阶段资料记录ID不能为空", false);
                    Assert.isNull(queryCycleStageDataDetailComReqDto.getThemeContentId(), "D4执行修正填报标准数据是否最新(公共)-D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交)-主题内容ID不能为空", false);
                    Assert.isNull(queryCycleStageDataDetailComReqDto.getSpaceId(), "D4执行修正填报标准数据是否最新(公共)-D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交)-创建于空间ID不能为空", false);
                    queryCycleStageDataDetailComRespDto = fwAppCycleStageDataClient.queryCycleStageDataDetailCom(queryCycleStageDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                if ((queryCycleStageDataDetailComRespDto != null && queryCycleStageDataDetailComRespDto.getSubjectLifeCycle() != null && queryCycleStageDataDetailComRespDto.getSubjectLifeCycle().equals("CURRENTLY_VALID")) && (reqDto != null && reqDto.getProgressValue() != null || reqDto != null && reqDto.getActualValue() != null)) {
                    //if(D3查询当前周期阶段资料详情(用于判断当前周期阶段资料是否已提交).主体生命周期 等于 当前有效 and (D4执行修正填报标准数据是否最新(公共).进度值（数值） 值不等于空  or D4执行修正填报标准数据是否最新(公共).实际值（数值） 值不等于空 ))  71579

                    List<OmsStandardDataResult> listOmsStandardDataResult = new ArrayList<>();
                    QueryStandardDataBaseListReq queryStandardDataBaseListReq = new QueryStandardDataBaseListReq();
                    queryStandardDataBaseListReq.setResultType("MANUAL_INPUT");//sourceId:1931982_1_71580
                    if (reqDto != null) {
                        queryStandardDataBaseListReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1932023_1_71580
                        queryStandardDataBaseListReq.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1931984_1_71580
                        queryStandardDataBaseListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1931985_1_71580
                        queryStandardDataBaseListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1931986_1_71580
                        queryStandardDataBaseListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1931987_1_71580
                    }

                    /*4-01-01查询当前周期人工录入标准数据列表[4495]   */
                    Assert.isNull(queryStandardDataBaseListReq.getResultType(), "D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-结果产生类型不能为空", false);
                    Assert.isNull(queryStandardDataBaseListReq.getParentSubMidCycleType(), "D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-父子中周期类型不能为空", false);
                    Assert.isNull(queryStandardDataBaseListReq.getPeriodId(), "D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-周期ID不能为空", false);
                    Assert.isNull(queryStandardDataBaseListReq.getEntityId(), "D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-归属内容表主键ID不能为空", false);
                    Assert.isNull(queryStandardDataBaseListReq.getThemeContentId(), "D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-主题内容ID不能为空", false);
                    Assert.isNull(queryStandardDataBaseListReq.getSpaceId(), "D4执行修正填报标准数据是否最新(公共)-4-01-01查询当前周期人工录入标准数据列表-创建于空间ID不能为空", false);
                    listOmsStandardDataResult = mOmsStandardDataResultService.queryStandardDataBaseList(queryStandardDataBaseListReq)/*vcase invoke 本地 method 方法调用;*/;


                    boolean bOOLEAN;
                    if (listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult) && listOmsStandardDataResult.size() > 0) {
                        List<OmsStandardDataResult> listOmsStandardDataResult_2 = new ArrayList<>();
                        if (listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult) && listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult)) {
                            listOmsStandardDataResult_2 = //objList-to-objLists
                                    listOmsStandardDataResult.stream().map(item -> {
                                        OmsStandardDataResult elm = new OmsStandardDataResult();
                                        elm.setDataResultId(item.getDataResultId());//SimpleFieldAssign//sourceId:393060_2_71581
                                        elm.setIsNewData("FALSE");//sourceId:393061_2_71581
                                        elm.setIsUpdateCycleNewData("FALSE");//sourceId:393064_2_71581
                                        return elm;
                                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:1931981_1_71581
                        }

                        /*4-01-01批量回写当前周期人工录入标准数据（归属与更新是否最新为否）[5688]   */

                        bOOLEAN = mOmsStandardDataResultService.batchUpdateStandardData(listOmsStandardDataResult_2)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
                if ((reqDto != null && reqDto.getDataResultId() != null && reqDto != null && reqDto.getBudgetDisburse() != null)) {
                    //if((D4执行修正填报标准数据是否最新(公共).数据结果ID  值不等于空  and D4执行修正填报标准数据是否最新(公共).预算支出金额 值不等于空 ))  71583

                    boolean bOOLEAN_1;
                    OmsStandardDataResult omsStandardDataResult = new OmsStandardDataResult();
                    omsStandardDataResult.setIsUpdateCycleNewData("FALSE");//sourceId:1932111_1_71584
                    omsStandardDataResult.setIsNewData("FALSE");//sourceId:1932112_1_71584
                    if (reqDto != null) {
                        omsStandardDataResult.setDataResultId(reqDto.getDataResultId());//SimpleFieldAssign//sourceId:1932110_1_71584
                    }

                    /*4-01-01回写预算支出金额标准数据（归属与更新周期是否最新为否）[2860]   */
                    Assert.isNull(omsStandardDataResult.getDataResultId(), "D4执行修正填报标准数据是否最新(公共)-4-01-01回写预算支出金额标准数据（归属与更新周期是否最新为否）-数据结果ID 不能为空", false);
                    Assert.isNull(omsStandardDataResult.getIsUpdateCycleNewData(), "D4执行修正填报标准数据是否最新(公共)-4-01-01回写预算支出金额标准数据（归属与更新周期是否最新为否）-是否更新周期最新数据不能为空", false);
                    Assert.isNull(omsStandardDataResult.getIsNewData(), "D4执行修正填报标准数据是否最新(公共)-4-01-01回写预算支出金额标准数据（归属与更新周期是否最新为否）-是否归属周期最新数据不能为空", false);
                    bOOLEAN_1 = mOmsStandardDataResultService.updateStandardData(omsStandardDataResult)/*vcase invoke 本地 method 方法调用;*/;


                }
            }
        }
        ImplementAdjustedFillInStandardDataIsNewestComRespDto retData = new ImplementAdjustedFillInStandardDataIsNewestComRespDto();


        return retData;
    }

    /**
     * D4执行修正并计算目标标准数据(公共)[9959]
     * gen by moon at 9/28/2024, 10:21:13 PM
     */
    @Trace(operationName = "D4执行修正并计算目标标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAdjustedAndCalcTargetStandardDataComRespDto implementAdjustedAndCalcTargetStandardDataCom(ImplementAdjustedAndCalcTargetStandardDataComReqDto reqDto) {


        //步骤0: M4执行计算公共接收字段（特殊方法） - implementCalcReceiveField
        //ModelCode: receptionService
        ImplementCalcReceiveFieldRespDto receptionServiceRes = null;
        ImplementCalcReceiveFieldReqDto receptionServiceReq = new ImplementCalcReceiveFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setApproveCalcScene(reqDto.getApproveCalcScene());//SimpleFieldAssign//sourceId:1932015_1
            receptionServiceReq.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1931682_1
            receptionServiceReq.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1931681_1
            receptionServiceReq.setDataResultId(reqDto.getDataResultId());//SimpleFieldAssign//sourceId:1931680_1
            receptionServiceReq.setBudgetDisburse(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1931683_1
            receptionServiceReq.setAccountSubjectld(reqDto.getAccountSubjectld());//SimpleFieldAssign//sourceId:1932006_1
            receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1931997_1
            receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1931998_1
            receptionServiceReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1932027_1
            receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1931686_1
            receptionServiceReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1932016_1
            receptionServiceReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1932008_1
            receptionServiceReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1931688_1
            receptionServiceReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1932011_1
            receptionServiceReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1931690_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1931999_1
        }

        /*M4接收入参字段[9725]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getApproveCalcScene(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-审核的计算场景不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjEntityId(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-主树被评对象内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaObjTypeCode(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-主树被评对象类型编码不能为空", false);
        Assert.isNull(receptionServiceReq.getParentSubMidCycleType(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-父子中周期类型不能为空", false);
        Assert.isNull(receptionServiceReq.getCycleId(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-归属周期ID不能为空", false);
        Assert.isNull(receptionServiceReq.getCycleStartTime(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-周期开始时间不能为空", false);
        Assert.isNull(receptionServiceReq.getCycleTypeCode(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-周期类型标识不能为空", false);
        Assert.isNull(receptionServiceReq.getEntityId(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-归属内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getBelongToContentId(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-数据归属内容表主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getThemeContentId(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-主题内容ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D4执行修正并计算目标标准数据(公共)-M4接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbEvaCalc.implementCalcReceiveField(receptionServiceReq);


//步骤1: D4提交汇报进度值实际值等(公共) - commitToBeReportedTaskStdDataCom
        CommitToBeReportedTaskStdDataComRespDto commitToBeReportedTaskStdDataComRespDto = null;
        CommitToBeReportedTaskStdDataComReqDto commitToBeReportedTaskStdDataComReqDto = new CommitToBeReportedTaskStdDataComReqDto();
        commitToBeReportedTaskStdDataComReqDto.setResultType("MANUAL_INPUT");//sourceId:1931569_1
        commitToBeReportedTaskStdDataComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1931576_1
        if (reqDto != null) {
            commitToBeReportedTaskStdDataComReqDto.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1931563_1
            commitToBeReportedTaskStdDataComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1931564_1
            commitToBeReportedTaskStdDataComReqDto.setBudgetDisburse(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1931565_1
            commitToBeReportedTaskStdDataComReqDto.setAccountSubjectld(reqDto.getAccountSubjectld());//SimpleFieldAssign//sourceId:1931575_1
            commitToBeReportedTaskStdDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1931574_1
            commitToBeReportedTaskStdDataComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1931566_1
            commitToBeReportedTaskStdDataComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1931570_1
            commitToBeReportedTaskStdDataComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1931571_1
            commitToBeReportedTaskStdDataComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1931572_1
            commitToBeReportedTaskStdDataComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1931573_1
            commitToBeReportedTaskStdDataComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1931567_1
            commitToBeReportedTaskStdDataComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1931568_1
        }

        /*D4提交汇报进度值实际值等(公共)[8637]   */
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getResultType(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-结果产生类型不能为空", false);
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getCycleId(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-归属周期ID不能为空", false);
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getCycleTypeCode(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-周期类型标识不能为空", false);
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getEntityId(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-归属内容表主键ID不能为空", false);
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getBelongToContentId(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-数据归属内容表主键ID不能为空", false);
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getEvaObjEntityId(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-主树被评对象内容表主键ID不能为空", false);
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getEvaObjTypeCode(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-主树被评对象类型编码不能为空", false);
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getEvaluationTemplateId(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getSubjectLifeCycle(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-主体生命周期不能为空", false);
        Assert.isNull(commitToBeReportedTaskStdDataComReqDto.getSpaceId(), "D4执行修正并计算目标标准数据(公共)-D4提交汇报进度值实际值等(公共)-创建于空间ID不能为空", false);
        commitToBeReportedTaskStdDataComRespDto = targetCalcService.commitToBeReportedTaskStdDataCom(commitToBeReportedTaskStdDataComReqDto)/*vcase invoke isSameApp*/;


        ImplementAdjustedAndCalcTargetStandardDataComRespDto retData = new ImplementAdjustedAndCalcTargetStandardDataComRespDto();


        return retData;
    }

    /**
     * D4执行删标准数据(公共)[9983]
     * gen by moon at 7/20/2024, 3:12:25 PM
     */
    @Trace(operationName = "D4执行删标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementDelStandardDataComRespDto implementDelStandardDataCom(ImplementDelStandardDataComReqDto reqDto) {


        //步骤0: 4-01-01查标准数据列表（归属周期开始大于等于&归属周期结束小于等于） - queryStandardDataList
        List<OmsStandardDataResult> listOmsStandardDataResult = new ArrayList<>();
        QueryStandardDataListReq queryStandardDataListReq = new QueryStandardDataListReq();
        if (reqDto != null) {
            queryStandardDataListReq.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1940088_1
            queryStandardDataListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1940086_1
        }

        /*4-01-01查标准数据列表[7719]   */
        Assert.isNull(queryStandardDataListReq.getFromContentEntityId(), "D4执行删标准数据(公共)-4-01-01查标准数据列表-来自内容表主键ID不能为空", false);
        Assert.isNull(queryStandardDataListReq.getThemeContentId(), "D4执行删标准数据(公共)-4-01-01查标准数据列表-主题内容ID不能为空", false);
        listOmsStandardDataResult = mOmsStandardDataResultService.queryStandardDataList(queryStandardDataListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 4-01-01批量删标准数据 - batchDeleteStandardData
        boolean bOOLEAN;
        if (listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult) && listOmsStandardDataResult.size() > 0) {
            List<String> listString = new ArrayList<>();
            if (listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult) && listOmsStandardDataResult != null && !CollectionUtil.isEmpty(listOmsStandardDataResult)) {
                listString = listOmsStandardDataResult.stream().map(item -> item.getDataResultId())
                        .collect(Collectors.toList());/*list-to-strings*///sourceId:1940064_1
            }

            /*4-01-01批量删标准数据[4216]   */

            bOOLEAN = mOmsStandardDataResultService.batchDeleteStandardData(listString)/*vcase invoke 本地 method 方法调用;*/;


        }

        ImplementDelStandardDataComRespDto retData = new ImplementDelStandardDataComRespDto();


        return retData;
    }

    /**
     * D4非末级周期向左克隆标准数据(公共)[10106]
     * gen by moon at 10/9/2024, 9:35:59 PM
     */
    @Trace(operationName = "D4非末级周期向左克隆标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementNonFinalCycleLeftCloneStandardDataComRespDto implementNonFinalCycleLeftCloneStandardDataCom(ImplementNonFinalCycleLeftCloneStandardDataComReqDto reqDto) {


        ImplementCloneProgressActualValueEtcComRespDto implementCloneProgressActualValueEtcComRespDto_1 = null;
//virtualUsage M4约定数据点：进度值与实际值  72324
        //ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes = null;
        ImplementCalcReceivingField006ReqDto receptionServiceReq = new ImplementCalcReceivingField006ReqDto();
        receptionServiceReq.setCustomField1("PROGRESS_VALUE");//CUSTOM_CONVENTION//sourceId:1978442_1_72324
        receptionServiceReq.setCustomField2("ACTUAL_VALUE");//CUSTOM_CONVENTION//sourceId:1978443_1_72324
        receptionServiceReq.setCustomField3("OBJECTIVE_SCORE");//CUSTOM_CONVENTION//sourceId:1978452_1_72324

        /*M4约定数据点：进度值与实际值[9540]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D4非末级周期向左克隆标准数据(公共)-M4约定数据点：进度值与实际值-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D4非末级周期向左克隆标准数据(公共)-M4约定数据点：进度值与实际值-自定义字段2不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField3(), "D4非末级周期向左克隆标准数据(公共)-M4约定数据点：进度值与实际值-自定义字段3不能为空", false);
        receptionServiceRes = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq);


//virtualUsage D2查主客观答案得分单位配置答案  72328
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1978477_1_72328
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SUBJECTIVE_FULL_MARK_UNIT");//CUSTOM_CONVENTION//sourceId:1978478_1_72328
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1978479_1_72328
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1978476_1_72328
        }

        /*D2查主客观答案得分单位配置答案[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D4非末级周期向左克隆标准数据(公共)-D2查主客观答案得分单位配置答案-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D4非末级周期向左克隆标准数据(公共)-D2查主客观答案得分单位配置答案-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D4非末级周期向左克隆标准数据(公共)-D2查主客观答案得分单位配置答案-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D4非末级周期向左克隆标准数据(公共)-D2查主客观答案得分单位配置答案-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3分析非末级周期的最近可循环周期ID(公共)  73167
        AnalysisNonFinalNextCycleIdComRespDto analysisNonFinalNextCycleIdComRespDto = null;
        AnalysisNonFinalNextCycleIdComReqDto analysisNonFinalNextCycleIdComReqDto = new AnalysisNonFinalNextCycleIdComReqDto();
        if (reqDto != null) {
            analysisNonFinalNextCycleIdComReqDto.setRecentlyNewCycleId(reqDto.getRecentlyNewCycleId());//SimpleFieldAssign//sourceId:2017332_1_73167
            analysisNonFinalNextCycleIdComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2017333_1_73167
            analysisNonFinalNextCycleIdComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:2017334_1_73167
        }

        /*D3分析非末级周期的最近可循环周期ID(公共)[10258]   */
        Assert.isNull(analysisNonFinalNextCycleIdComReqDto.getEvaObjTargetCycleId(), "D4非末级周期向左克隆标准数据(公共)-D3分析非末级周期的最近可循环周期ID(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(analysisNonFinalNextCycleIdComReqDto.getEvaluationTemplateId(), "D4非末级周期向左克隆标准数据(公共)-D3分析非末级周期的最近可循环周期ID(公共)-冗余评价模板ID不能为空", false);
        analysisNonFinalNextCycleIdComRespDto = fwAppEvaCalcClient.analysisNonFinalNextCycleIdCom(analysisNonFinalNextCycleIdComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D4查询最近可循环最新进度值实际值(用于克隆)  72316
        ImplementCloneProgressActualValueEtcComRespDto implementCloneProgressActualValueEtcComRespDto = null;
        if (analysisNonFinalNextCycleIdComRespDto != null) {
            ImplementCloneProgressActualValueEtcComReqDto implementCloneProgressActualValueEtcComReqDto = new ImplementCloneProgressActualValueEtcComReqDto();
            implementCloneProgressActualValueEtcComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1977958_1_72316
            implementCloneProgressActualValueEtcComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1977959_1_72316
            if (reqDto != null) {
                implementCloneProgressActualValueEtcComReqDto.setEvaProgressCalcCode(reqDto.getEvaProgressCalcCode());//SimpleFieldAssign//sourceId:1977947_1_72316
                implementCloneProgressActualValueEtcComReqDto.setEvaActualCalcCode(reqDto.getEvaActualCalcCode());//SimpleFieldAssign//sourceId:1977948_1_72316
                implementCloneProgressActualValueEtcComReqDto.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:1977949_1_72316
                implementCloneProgressActualValueEtcComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:1977950_1_72316
                implementCloneProgressActualValueEtcComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1977951_1_72316
                implementCloneProgressActualValueEtcComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1977952_1_72316
                implementCloneProgressActualValueEtcComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1977960_1_72316
                implementCloneProgressActualValueEtcComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1977953_1_72316
                implementCloneProgressActualValueEtcComReqDto.setCycleId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1977954_1_72316
                implementCloneProgressActualValueEtcComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1977955_1_72316
                implementCloneProgressActualValueEtcComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1977956_1_72316
                implementCloneProgressActualValueEtcComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1977957_1_72316
            }
            if (analysisNonFinalNextCycleIdComRespDto != null) {
                implementCloneProgressActualValueEtcComReqDto.setRecentlyNewCycleId(analysisNonFinalNextCycleIdComRespDto.getRecentlyNewCycleId());//SimpleFieldAssign//sourceId:1977967_1_72316
            }

            /*D4查询最近可循环最新进度值实际值(用于克隆)[9429]   */
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getEvaObjEntityId(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-主树被评对象内容表主键ID不能为空", false);
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getEvaObjTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-主树被评对象类型编码不能为空", false);
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getParentSubMidCycleType(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-父子中周期类型不能为空", false);
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getEntityId(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-归属内容表主键ID不能为空", false);
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getCycleId(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-归属周期ID不能为空", false);
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getCycleTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-周期类型标识不能为空", false);
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getBelongToContentId(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-数据归属内容表主键ID不能为空", false);
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getEvaluationTemplateId(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-冗余评价模板ID不能为空", false);
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getSubjectLifeCycle(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-主体生命周期不能为空", false);
            Assert.isNull(implementCloneProgressActualValueEtcComReqDto.getSpaceId(), "D4非末级周期向左克隆标准数据(公共)-D4查询最近可循环最新进度值实际值(用于克隆)-创建于空间ID不能为空", false);
            implementCloneProgressActualValueEtcComRespDto = targetCalcService.implementCloneProgressActualValueEtcCom(implementCloneProgressActualValueEtcComReqDto)/*vcase invoke isSameApp*/;


            implementCloneProgressActualValueEtcComRespDto_1 = implementCloneProgressActualValueEtcComRespDto;
        }
        if ((implementCloneProgressActualValueEtcComRespDto != null && implementCloneProgressActualValueEtcComRespDto.getProgressValue() != null || implementCloneProgressActualValueEtcComRespDto != null && implementCloneProgressActualValueEtcComRespDto.getActualValue() != null)) {
            //if((D4查询最近可循环最新进度值实际值(用于克隆).进度值（数值） 值不等于空  or D4查询最近可循环最新进度值实际值(用于克隆).实际值（数值） 值不等于空 ))  72317

            CalculateFinalObjectiveScoreComRespDto calculateFinalObjectiveScoreComRespDto = null;
            if (implementCloneProgressActualValueEtcComRespDto != null) {
                CalculateFinalObjectiveScoreComReqDto calculateFinalObjectiveScoreComReqDto = new CalculateFinalObjectiveScoreComReqDto();
                calculateFinalObjectiveScoreComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1977973_1_72318
                if (reqDto != null) {
                    calculateFinalObjectiveScoreComReqDto.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:1977983_1_72318
                    calculateFinalObjectiveScoreComReqDto.setActualValueCalcFormula(reqDto.getEvaActualCalcCode());//SimpleFieldAssign//sourceId:1977968_1_72318
                    calculateFinalObjectiveScoreComReqDto.setCalcOrClone(reqDto.getEvaReportScoreCalcCode());//SimpleFieldAssign//sourceId:1977969_1_72318
                    calculateFinalObjectiveScoreComReqDto.setReportScoreCountFormula(reqDto.getRankOrDownCalc());//SimpleFieldAssign//sourceId:1977974_1_72318
                    calculateFinalObjectiveScoreComReqDto.setSubAndObjModel(reqDto.getSubAndObjModel());//SimpleFieldAssign//sourceId:1977970_1_72318
                    calculateFinalObjectiveScoreComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1977984_1_72318
                    calculateFinalObjectiveScoreComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1977985_1_72318
                    calculateFinalObjectiveScoreComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1977976_1_72318
                    calculateFinalObjectiveScoreComReqDto.setTargetCycleContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1977975_1_72318
                    calculateFinalObjectiveScoreComReqDto.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:1977971_1_72318
                    calculateFinalObjectiveScoreComReqDto.setEvaTargetStartValue(reqDto.getEvaTargetStartValue());//SimpleFieldAssign//sourceId:1977978_1_72318
                    calculateFinalObjectiveScoreComReqDto.setEvaTargetValue(reqDto.getEvaTargetValue());//SimpleFieldAssign//sourceId:1977979_1_72318
                    calculateFinalObjectiveScoreComReqDto.setEvaTargetDiagnosticValue(reqDto.getEvaTargetDiagnosticValue());//SimpleFieldAssign//sourceId:1977980_1_72318
                    calculateFinalObjectiveScoreComReqDto.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:1977977_1_72318
                    calculateFinalObjectiveScoreComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1977972_1_72318
                }
                if (implementCloneProgressActualValueEtcComRespDto != null) {
                    calculateFinalObjectiveScoreComReqDto.setActualValue(implementCloneProgressActualValueEtcComRespDto.getActualValue());//SimpleFieldAssign//sourceId:1977981_1_72318
                }

                /*D3计算指标最终客观得分(公共)[9442]   */
                Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetAttributionCycleId(), "D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-目标归属周期ID不能为空", false);
                Assert.isNull(calculateFinalObjectiveScoreComReqDto.getUpdateCycleId(), "D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-更新周期ID不能为空", false);
                Assert.isNull(calculateFinalObjectiveScoreComReqDto.getEvaObjTargetCycleId(), "D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetCycleContentTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetCycleContentId(), "D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(calculateFinalObjectiveScoreComReqDto.getWeightScore(), "D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-权重分值不能为空", false);
                Assert.isNull(calculateFinalObjectiveScoreComReqDto.getEvaluationTemplateId(), "D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(calculateFinalObjectiveScoreComReqDto.getSpaceId(), "D4非末级周期向左克隆标准数据(公共)-D3计算指标最终客观得分(公共)-创建于空间ID不能为空", false);
                calculateFinalObjectiveScoreComRespDto = fwAppTargetCalcClient.calculateFinalObjectiveScoreCom(calculateFinalObjectiveScoreComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementCloneProgressActualValueEtcComRespDto != null && implementCloneProgressActualValueEtcComRespDto.getProgressValue() != null)) {
                //if(D4查询最近可循环最新进度值实际值(用于克隆).进度值（数值） 值不等于空 )  72319

                RefreshDataPointStandardDataComRespDto refreshDataPointStandardDataComRespDto = null;
                if (implementCloneProgressActualValueEtcComRespDto != null) {
                    RefreshDataPointStandardDataComReqDto refreshDataPointStandardDataComReqDto = new RefreshDataPointStandardDataComReqDto();
                    refreshDataPointStandardDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1978202_1_72322
                    refreshDataPointStandardDataComReqDto.setIsSystemDocking("FALSE");//sourceId:1978203_1_72322
                    refreshDataPointStandardDataComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1978205_1_72322
                    refreshDataPointStandardDataComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1978226_1_72322
                    refreshDataPointStandardDataComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1978239_1_72322
                    if (implementCloneProgressActualValueEtcComRespDto != null) {
                        refreshDataPointStandardDataComReqDto.setDataResult(implementCloneProgressActualValueEtcComRespDto.getProgressValue());//SimpleFieldAssign//sourceId:1978200_1_72322
                        refreshDataPointStandardDataComReqDto.setUnit(implementCloneProgressActualValueEtcComRespDto.getProgressValueUnit());//SimpleFieldAssign//sourceId:1978201_1_72322
                    }
                    if (receptionServiceRes != null) {
                        refreshDataPointStandardDataComReqDto.setDataType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1978204_1_72322
                    }
                    if (reqDto != null) {
                        refreshDataPointStandardDataComReqDto.setPreviousCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1978242_1_72322
                        refreshDataPointStandardDataComReqDto.setLastEntityId(reqDto.getLastEntityId());//SimpleFieldAssign//sourceId:1978245_1_72322
                        refreshDataPointStandardDataComReqDto.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1978243_1_72322
                        refreshDataPointStandardDataComReqDto.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1978206_1_72322
                        refreshDataPointStandardDataComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1978207_1_72322
                        refreshDataPointStandardDataComReqDto.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1978208_1_72322
                        refreshDataPointStandardDataComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1978209_1_72322
                        refreshDataPointStandardDataComReqDto.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1978210_1_72322
                        refreshDataPointStandardDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1978211_1_72322
                        refreshDataPointStandardDataComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1978212_1_72322
                        refreshDataPointStandardDataComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1978213_1_72322
                        refreshDataPointStandardDataComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1978214_1_72322
                        refreshDataPointStandardDataComReqDto.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1978215_1_72322
                        refreshDataPointStandardDataComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1978216_1_72322
                        refreshDataPointStandardDataComReqDto.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1978217_1_72322
                        refreshDataPointStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1978241_1_72322
                        refreshDataPointStandardDataComReqDto.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1978218_1_72322
                        refreshDataPointStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1978219_1_72322
                        refreshDataPointStandardDataComReqDto.setFromContentTableTypeCode(reqDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1978220_1_72322
                        refreshDataPointStandardDataComReqDto.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1978221_1_72322
                        refreshDataPointStandardDataComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1978222_1_72322
                        refreshDataPointStandardDataComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1978223_1_72322
                        refreshDataPointStandardDataComReqDto.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1978224_1_72322
                        refreshDataPointStandardDataComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1978225_1_72322
                        refreshDataPointStandardDataComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1978227_1_72322
                        refreshDataPointStandardDataComReqDto.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1978229_1_72322
                        refreshDataPointStandardDataComReqDto.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1978230_1_72322
                        refreshDataPointStandardDataComReqDto.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1978231_1_72322
                        refreshDataPointStandardDataComReqDto.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1978246_1_72322
                        refreshDataPointStandardDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1978232_1_72322
                        refreshDataPointStandardDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1978233_1_72322
                        refreshDataPointStandardDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1978234_1_72322
                        refreshDataPointStandardDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1978235_1_72322
                        refreshDataPointStandardDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1978236_1_72322
                        refreshDataPointStandardDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1978237_1_72322
                        refreshDataPointStandardDataComReqDto.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1978244_1_72322
                        refreshDataPointStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1978238_1_72322
                        refreshDataPointStandardDataComReqDto.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1978240_1_72322
                    }

                    /*D4克隆数据点标准数据(公共)[8559]   */
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getDataResult(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据值结果不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getUnit(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-冗余单位不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getResultType(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-结果产生类型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getIsSystemDocking(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否系统对接不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getDataType(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据点类型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getDataUsageSceneCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据业务场景不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getPeriodId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getCycleStartTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期开始时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getCycleEndTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期结束时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getCycleTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期类型标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getUpdateCycleId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getUpdateCycleStartTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期开始时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getUpdateCycleEndTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期结束时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getUpdateCycleTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期类型标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getStandardDataCalcCycleModel(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算周期五模型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getParentSubMidCycleType(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-父子中周期类型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getIsWorkCycleData(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否工作周期数据不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getEventBatchUpdateCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-事务内数据更新批次标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getWorkCycleUpdateSlice(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-工作周期更新切片不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getCalcStartTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算开始时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getTableTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getEntityId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表主键ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToContentTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToContentId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表主键ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getThemeContentTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getThemeContentId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getPersonLiableTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人身份类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getPersonLiableObjId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人对象ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getBizRoleObjId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getBizRoleObjCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getBizRoleObjName(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象名称不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToPersonalIdentityId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToPersonalIdentityRoleCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象角色编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getSubjectLifeCycle(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主体生命周期不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto.getOperationInductionId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-操作人就职记录ID不能为空", false);
                    refreshDataPointStandardDataComRespDto = standardDataService.refreshDataPointStandardDataCom(refreshDataPointStandardDataComReqDto)/*vcase invoke isSameApp*/;


                }
            }
            if ((implementCloneProgressActualValueEtcComRespDto != null && implementCloneProgressActualValueEtcComRespDto.getActualValue() != null)) {
                //if(D4查询最近可循环最新进度值实际值(用于克隆).实际值（数值） 值不等于空 )  72321

                RefreshDataPointStandardDataComRespDto refreshDataPointStandardDataComRespDto_1 = null;
                if (implementCloneProgressActualValueEtcComRespDto != null) {
                    RefreshDataPointStandardDataComReqDto refreshDataPointStandardDataComReqDto_1 = new RefreshDataPointStandardDataComReqDto();
                    refreshDataPointStandardDataComReqDto_1.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1978202_1_72323
                    refreshDataPointStandardDataComReqDto_1.setIsSystemDocking("FALSE");//sourceId:1978203_1_72323
                    refreshDataPointStandardDataComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1978205_1_72323
                    refreshDataPointStandardDataComReqDto_1.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1978226_1_72323
                    refreshDataPointStandardDataComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1978239_1_72323
                    if (implementCloneProgressActualValueEtcComRespDto != null) {
                        refreshDataPointStandardDataComReqDto_1.setDataResult(implementCloneProgressActualValueEtcComRespDto.getActualValue());//SimpleFieldAssign//sourceId:1978200_1_72323
                        refreshDataPointStandardDataComReqDto_1.setUnit(implementCloneProgressActualValueEtcComRespDto.getActualValueUnit());//SimpleFieldAssign//sourceId:1978201_1_72323
                    }
                    if (receptionServiceRes != null) {
                        refreshDataPointStandardDataComReqDto_1.setDataType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1978204_1_72323
                    }
                    if (reqDto != null) {
                        refreshDataPointStandardDataComReqDto_1.setPreviousCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1978242_1_72323
                        refreshDataPointStandardDataComReqDto_1.setLastEntityId(reqDto.getLastEntityId());//SimpleFieldAssign//sourceId:1978245_1_72323
                        refreshDataPointStandardDataComReqDto_1.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1978243_1_72323
                        refreshDataPointStandardDataComReqDto_1.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1978206_1_72323
                        refreshDataPointStandardDataComReqDto_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1978207_1_72323
                        refreshDataPointStandardDataComReqDto_1.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1978208_1_72323
                        refreshDataPointStandardDataComReqDto_1.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1978209_1_72323
                        refreshDataPointStandardDataComReqDto_1.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1978210_1_72323
                        refreshDataPointStandardDataComReqDto_1.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1978211_1_72323
                        refreshDataPointStandardDataComReqDto_1.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1978212_1_72323
                        refreshDataPointStandardDataComReqDto_1.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1978213_1_72323
                        refreshDataPointStandardDataComReqDto_1.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1978214_1_72323
                        refreshDataPointStandardDataComReqDto_1.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1978215_1_72323
                        refreshDataPointStandardDataComReqDto_1.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1978216_1_72323
                        refreshDataPointStandardDataComReqDto_1.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1978217_1_72323
                        refreshDataPointStandardDataComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1978241_1_72323
                        refreshDataPointStandardDataComReqDto_1.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1978218_1_72323
                        refreshDataPointStandardDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1978219_1_72323
                        refreshDataPointStandardDataComReqDto_1.setFromContentTableTypeCode(reqDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1978220_1_72323
                        refreshDataPointStandardDataComReqDto_1.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1978221_1_72323
                        refreshDataPointStandardDataComReqDto_1.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1978222_1_72323
                        refreshDataPointStandardDataComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1978223_1_72323
                        refreshDataPointStandardDataComReqDto_1.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1978224_1_72323
                        refreshDataPointStandardDataComReqDto_1.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1978225_1_72323
                        refreshDataPointStandardDataComReqDto_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1978227_1_72323
                        refreshDataPointStandardDataComReqDto_1.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1978229_1_72323
                        refreshDataPointStandardDataComReqDto_1.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1978230_1_72323
                        refreshDataPointStandardDataComReqDto_1.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1978231_1_72323
                        refreshDataPointStandardDataComReqDto_1.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1978246_1_72323
                        refreshDataPointStandardDataComReqDto_1.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1978232_1_72323
                        refreshDataPointStandardDataComReqDto_1.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1978233_1_72323
                        refreshDataPointStandardDataComReqDto_1.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1978234_1_72323
                        refreshDataPointStandardDataComReqDto_1.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1978235_1_72323
                        refreshDataPointStandardDataComReqDto_1.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1978236_1_72323
                        refreshDataPointStandardDataComReqDto_1.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1978237_1_72323
                        refreshDataPointStandardDataComReqDto_1.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1978244_1_72323
                        refreshDataPointStandardDataComReqDto_1.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1978238_1_72323
                        refreshDataPointStandardDataComReqDto_1.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1978240_1_72323
                    }

                    /*D4克隆数据点标准数据(公共)[8559]   */
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getDataResult(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据值结果不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUnit(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-冗余单位不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getResultType(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-结果产生类型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getIsSystemDocking(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否系统对接不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getDataType(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据点类型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getDataUsageSceneCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据业务场景不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getPeriodId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getCycleStartTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期开始时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getCycleEndTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期结束时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getCycleTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期类型标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUpdateCycleId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUpdateCycleStartTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期开始时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUpdateCycleEndTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期结束时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getUpdateCycleTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期类型标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getStandardDataCalcCycleModel(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算周期五模型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getParentSubMidCycleType(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-父子中周期类型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getIsWorkCycleData(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否工作周期数据不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getEventBatchUpdateCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-事务内数据更新批次标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getWorkCycleUpdateSlice(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-工作周期更新切片不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getCalcStartTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算开始时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getTableTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getEntityId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表主键ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToContentTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToContentId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表主键ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getThemeContentTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getThemeContentId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getPersonLiableTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人身份类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getPersonLiableObjId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人对象ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBizRoleObjId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBizRoleObjCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBizRoleObjName(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象名称不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToPersonalIdentityId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToPersonalIdentityRoleCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象角色编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getBelongToPersonalIdentityTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getSubjectLifeCycle(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主体生命周期不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_1.getOperationInductionId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-操作人就职记录ID不能为空", false);
                    refreshDataPointStandardDataComRespDto_1 = standardDataService.refreshDataPointStandardDataCom(refreshDataPointStandardDataComReqDto_1)/*vcase invoke isSameApp*/;


                }
            }
            if ((calculateFinalObjectiveScoreComRespDto != null && calculateFinalObjectiveScoreComRespDto.getObjectiveScore() != null)) {
                //if(D3计算指标最终客观得分(公共).客观得分 值不等于空 )  72326

                RefreshDataPointStandardDataComRespDto refreshDataPointStandardDataComRespDto_2 = null;
                if (calculateFinalObjectiveScoreComRespDto != null && queryConfItemMatchAnswerDetailComRespDto != null) {
                    RefreshDataPointStandardDataComReqDto refreshDataPointStandardDataComReqDto_2 = new RefreshDataPointStandardDataComReqDto();
                    refreshDataPointStandardDataComReqDto_2.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1978202_1_72327
                    refreshDataPointStandardDataComReqDto_2.setIsSystemDocking("FALSE");//sourceId:1978203_1_72327
                    refreshDataPointStandardDataComReqDto_2.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1978205_1_72327
                    refreshDataPointStandardDataComReqDto_2.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1978226_1_72327
                    refreshDataPointStandardDataComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1978239_1_72327
                    if (calculateFinalObjectiveScoreComRespDto != null) {
                        refreshDataPointStandardDataComReqDto_2.setDataResult(calculateFinalObjectiveScoreComRespDto.getObjectiveScore());//SimpleFieldAssign//sourceId:1978200_1_72327
                    }
                    if (queryConfItemMatchAnswerDetailComRespDto != null) {
                        refreshDataPointStandardDataComReqDto_2.setUnit(queryConfItemMatchAnswerDetailComRespDto.getConfOptionName());//SimpleFieldAssign//sourceId:1978201_1_72327
                    }
                    if (receptionServiceRes != null) {
                        refreshDataPointStandardDataComReqDto_2.setDataType(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1978204_1_72327
                    }
                    if (reqDto != null) {
                        refreshDataPointStandardDataComReqDto_2.setPreviousCycleId(reqDto.getPreviousCycleId());//SimpleFieldAssign//sourceId:1978242_1_72327
                        refreshDataPointStandardDataComReqDto_2.setLastEntityId(reqDto.getLastEntityId());//SimpleFieldAssign//sourceId:1978245_1_72327
                        refreshDataPointStandardDataComReqDto_2.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1978243_1_72327
                        refreshDataPointStandardDataComReqDto_2.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1978206_1_72327
                        refreshDataPointStandardDataComReqDto_2.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1978207_1_72327
                        refreshDataPointStandardDataComReqDto_2.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1978208_1_72327
                        refreshDataPointStandardDataComReqDto_2.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1978209_1_72327
                        refreshDataPointStandardDataComReqDto_2.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1978210_1_72327
                        refreshDataPointStandardDataComReqDto_2.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1978211_1_72327
                        refreshDataPointStandardDataComReqDto_2.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1978212_1_72327
                        refreshDataPointStandardDataComReqDto_2.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1978213_1_72327
                        refreshDataPointStandardDataComReqDto_2.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1978214_1_72327
                        refreshDataPointStandardDataComReqDto_2.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1978215_1_72327
                        refreshDataPointStandardDataComReqDto_2.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1978216_1_72327
                        refreshDataPointStandardDataComReqDto_2.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1978217_1_72327
                        refreshDataPointStandardDataComReqDto_2.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1978241_1_72327
                        refreshDataPointStandardDataComReqDto_2.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1978218_1_72327
                        refreshDataPointStandardDataComReqDto_2.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1978219_1_72327
                        refreshDataPointStandardDataComReqDto_2.setFromContentTableTypeCode(reqDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1978220_1_72327
                        refreshDataPointStandardDataComReqDto_2.setFromContentEntityId(reqDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1978221_1_72327
                        refreshDataPointStandardDataComReqDto_2.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1978222_1_72327
                        refreshDataPointStandardDataComReqDto_2.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1978223_1_72327
                        refreshDataPointStandardDataComReqDto_2.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1978224_1_72327
                        refreshDataPointStandardDataComReqDto_2.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1978225_1_72327
                        refreshDataPointStandardDataComReqDto_2.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1978227_1_72327
                        refreshDataPointStandardDataComReqDto_2.setExtendedField1(reqDto.getExtendedField1());//SimpleFieldAssign//sourceId:1978229_1_72327
                        refreshDataPointStandardDataComReqDto_2.setExtendedField2(reqDto.getExtendedField2());//SimpleFieldAssign//sourceId:1978230_1_72327
                        refreshDataPointStandardDataComReqDto_2.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1978231_1_72327
                        refreshDataPointStandardDataComReqDto_2.setExtendedField4(reqDto.getExtendedField4());//SimpleFieldAssign//sourceId:1978246_1_72327
                        refreshDataPointStandardDataComReqDto_2.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1978232_1_72327
                        refreshDataPointStandardDataComReqDto_2.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1978233_1_72327
                        refreshDataPointStandardDataComReqDto_2.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1978234_1_72327
                        refreshDataPointStandardDataComReqDto_2.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1978235_1_72327
                        refreshDataPointStandardDataComReqDto_2.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1978236_1_72327
                        refreshDataPointStandardDataComReqDto_2.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1978237_1_72327
                        refreshDataPointStandardDataComReqDto_2.setBelongToPersonalIdentityRoleCode(reqDto.getBelongToPersonalIdentityRoleCode());//SimpleFieldAssign//sourceId:1978244_1_72327
                        refreshDataPointStandardDataComReqDto_2.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1978238_1_72327
                        refreshDataPointStandardDataComReqDto_2.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1978240_1_72327
                    }

                    /*D4克隆数据点标准数据(公共)[8559]   */
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getDataResult(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据值结果不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUnit(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-冗余单位不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getResultType(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-结果产生类型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getIsSystemDocking(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否系统对接不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getDataType(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据点类型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getDataUsageSceneCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据业务场景不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getPeriodId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getCycleStartTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期开始时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getCycleEndTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期结束时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getCycleTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-周期类型标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUpdateCycleId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUpdateCycleStartTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期开始时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUpdateCycleEndTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期结束时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getUpdateCycleTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-更新周期类型标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getStandardDataCalcCycleModel(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算周期五模型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getParentSubMidCycleType(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-父子中周期类型不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getIsWorkCycleData(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-是否工作周期数据不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getEventBatchUpdateCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-事务内数据更新批次标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getWorkCycleUpdateSlice(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-工作周期更新切片不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getCalcStartTime(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-计算开始时间不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getTableTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getEntityId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-归属内容表主键ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToContentTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToContentId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属内容表主键ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getThemeContentTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getThemeContentId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主题内容ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getPersonLiableTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人身份类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getPersonLiableObjId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人对象ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBizRoleObjId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBizRoleObjCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色标识不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBizRoleObjName(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-填报评价责任人业务角色对象名称不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToPersonalIdentityId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象ID不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToPersonalIdentityRoleCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象角色编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getBelongToPersonalIdentityTypeCode(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-数据归属对象类型编码不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getSubjectLifeCycle(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-主体生命周期不能为空", false);
                    Assert.isNull(refreshDataPointStandardDataComReqDto_2.getOperationInductionId(), "D4非末级周期向左克隆标准数据(公共)-D4克隆数据点标准数据(公共)-操作人就职记录ID不能为空", false);
                    refreshDataPointStandardDataComRespDto_2 = standardDataService.refreshDataPointStandardDataCom(refreshDataPointStandardDataComReqDto_2)/*vcase invoke isSameApp*/;


                }
            }
        }
        ImplementNonFinalCycleLeftCloneStandardDataComRespDto retData = new ImplementNonFinalCycleLeftCloneStandardDataComRespDto();
        if (implementCloneProgressActualValueEtcComRespDto_1 != null) {
            retData.setProgressValue(implementCloneProgressActualValueEtcComRespDto_1.getProgressValue());//SimpleFieldAssign//sourceId:1978480_1
            retData.setParentProgressValue(implementCloneProgressActualValueEtcComRespDto_1.getParentProgressValue());//SimpleFieldAssign//sourceId:1978481_1
            retData.setProgressValueUnit(implementCloneProgressActualValueEtcComRespDto_1.getProgressValueUnit());//SimpleFieldAssign//sourceId:1978543_1
            retData.setActualValue(implementCloneProgressActualValueEtcComRespDto_1.getActualValue());//SimpleFieldAssign//sourceId:1978482_1
            retData.setParentActualValue(implementCloneProgressActualValueEtcComRespDto_1.getParentActualValue());//SimpleFieldAssign//sourceId:1978483_1
            retData.setActualValueUnit(implementCloneProgressActualValueEtcComRespDto_1.getActualValueUnit());//SimpleFieldAssign//sourceId:1978544_1
        }


        return retData;
    }

    /**
     * D4判断当前周期是否存在标准数据(公共)[10259]
     * gen by moon at 10/15/2024, 8:51:38 PM
     */
    @Trace(operationName = "D4判断当前周期是否存在标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeCurCycleIsHaveDataComRespDto judgeCurCycleIsHaveDataCom(JudgeCurCycleIsHaveDataComReqDto reqDto) {


        ImplementCalcReceivingField006RespDto receptionServiceRes_3 = null;
//virtualUsage M4约定结果产生类型、是否  73175
        //ModelCode: receptionService
        ImplementCalcReceivingField006RespDto receptionServiceRes = null;
        ImplementCalcReceivingField006ReqDto receptionServiceReq = new ImplementCalcReceivingField006ReqDto();
        receptionServiceReq.setCustomField1("MANUAL_INPUT");//CUSTOM_CONVENTION//sourceId:2017750_1_73175
        receptionServiceReq.setCustomField2("TRUE");//CUSTOM_CONVENTION//sourceId:2017852_1_73175

        /*M4约定结果产生类型、是否[9540]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D4判断当前周期是否存在标准数据(公共)-M4约定结果产生类型、是否-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D4判断当前周期是否存在标准数据(公共)-M4约定结果产生类型、是否-自定义字段2不能为空", false);
        receptionServiceRes = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq);


        if ((reqDto != null && reqDto.getBrushStandardDataSence() != null && reqDto.getBrushStandardDataSence().equals("REPORT_DATA_SENCE"))) {
            //if(D4判断当前周期是否存在标准数据(公共).刷新标准数据场景 等于 汇报数据场景)  73171

            QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto = null;
            QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto = new QueryStandardDataOfObjectDetailComReqDto();
            queryStandardDataOfObjectDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2017539_1_73173
            queryStandardDataOfObjectDetailComReqDto.setIsArchive("FALSE");//sourceId:2017547_1_73173
            if (receptionServiceRes != null) {
                queryStandardDataOfObjectDetailComReqDto.setResultType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:2017550_1_73173
            }
            if (reqDto != null) {
                queryStandardDataOfObjectDetailComReqDto.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:2017523_1_73173
                queryStandardDataOfObjectDetailComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2017537_1_73173
                queryStandardDataOfObjectDetailComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2017525_1_73173
                queryStandardDataOfObjectDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2017527_1_73173
                queryStandardDataOfObjectDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2017534_1_73173
            }

            /*D4查询归属主体标准数据详情(公共)[8850]   */
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getPeriodId(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-周期ID不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getParentSubMidCycleType(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-父子中周期类型不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getThemeContentId(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-主题内容ID不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataUsageSceneCode(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-数据业务场景不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getIsArchive(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-是否存档不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getSpaceId(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-创建于空间ID不能为空", false);
            queryStandardDataOfObjectDetailComRespDto = standardDataService.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto)/*vcase invoke isSameApp*/;


            if ((queryStandardDataOfObjectDetailComRespDto != null && queryStandardDataOfObjectDetailComRespDto.getDataResultId() != null && reqDto != null && reqDto.getFromContentEntityId() != null)) {
                //if((D4查询当前周期是否存在人工填报标准数据(用于判断当前牌是否执行目标计算).数据结果ID  值不等于空  and D4判断当前周期是否存在标准数据(公共).来自内容表主键ID 值不等于空 ))  73177

//ModelCode: receptionService
                ImplementCalcReceivingField006RespDto receptionServiceRes_2 = null;
                ImplementCalcReceivingField006ReqDto receptionServiceReq_1 = new ImplementCalcReceivingField006ReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_1.setDataIsCheckPass(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:2017850_1_73179
                }

                /*M4接收出参字段：数据是否校验通过[9540]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getDataIsCheckPass(), "D4判断当前周期是否存在标准数据(公共)-M4接收出参字段：数据是否校验通过-数据是否校验通过不能为空", false);
                receptionServiceRes_2 = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq_1);


                receptionServiceRes_3 = receptionServiceRes_2;
            }
        } else if ((reqDto != null && reqDto.getBrushStandardDataSence() != null && reqDto.getBrushStandardDataSence().equals("REVISE_TARGET_DATA_SENCE"))) {
            //elseif(D4判断当前周期是否存在标准数据(公共).刷新标准数据场景 等于 修订目标数据场景)  73172

            QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto_2 = null;
            QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto_1 = new QueryStandardDataOfObjectDetailComReqDto();
            queryStandardDataOfObjectDetailComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2017539_1_73174
            queryStandardDataOfObjectDetailComReqDto_1.setIsArchive("FALSE");//sourceId:2017547_1_73174
            if (reqDto != null) {
                queryStandardDataOfObjectDetailComReqDto_1.setPeriodId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:2017523_1_73174
                queryStandardDataOfObjectDetailComReqDto_1.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2017525_1_73174
                queryStandardDataOfObjectDetailComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2017527_1_73174
                queryStandardDataOfObjectDetailComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2017534_1_73174
            }

            /*D4查询归属主体标准数据详情(公共)[8850]   */
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getPeriodId(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-周期ID不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getParentSubMidCycleType(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-父子中周期类型不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getThemeContentId(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-主题内容ID不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getDataUsageSceneCode(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-数据业务场景不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getIsArchive(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-是否存档不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getSpaceId(), "D4判断当前周期是否存在标准数据(公共)-D4查询归属主体标准数据详情(公共)-创建于空间ID不能为空", false);
            queryStandardDataOfObjectDetailComRespDto_2 = standardDataService.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto_1)/*vcase invoke isSameApp*/;


            if ((queryStandardDataOfObjectDetailComRespDto_2 != null && queryStandardDataOfObjectDetailComRespDto_2.getDataResultId() != null)) {
                //if(D4查询当前周期是否存在标准数据(用于判断当前牌是否执行目标计算).数据结果ID  值不等于空 )  73181

//ModelCode: receptionService
                ImplementCalcReceivingField006RespDto receptionServiceRes_4 = null;
                ImplementCalcReceivingField006ReqDto receptionServiceReq_2 = new ImplementCalcReceivingField006ReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_2.setDataIsCheckPass(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:2017850_1_73182
                }

                /*M4接收出参字段：数据是否校验通过[9540]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getDataIsCheckPass(), "D4判断当前周期是否存在标准数据(公共)-M4接收出参字段：数据是否校验通过-数据是否校验通过不能为空", false);
                receptionServiceRes_4 = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq_2);


                receptionServiceRes_3 = receptionServiceRes_4;
            }
        }
        JudgeCurCycleIsHaveDataComRespDto retData = new JudgeCurCycleIsHaveDataComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setDataIsCheckPass(receptionServiceRes_3.getDataIsCheckPass());//SimpleFieldAssign//sourceId:2017856_1
        }


        return retData;
    }

    /**
     * D4查询标准数据by小于等于开始时间大于等于结束时间详情(公共)[10278]
     * gen by moon at 10/22/2024, 12:07:12 AM
     */
    @Trace(operationName = "D4查询标准数据by小于等于开始时间大于等于结束时间详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryStandardDataBySmallStartAndBigEndDetailComRespDto queryStandardDataBySmallStartAndBigEndDetailCom(QueryStandardDataBySmallStartAndBigEndDetailComReqDto reqDto) {


        OmsStandardDataResult omsStandardDataResult_1 = null;
//步骤0: 4-01-01查询标准数据详情by小于等于开始时间大于等于结束时间 - queryStandardDataBySmallStartAndBigEndDetail
        OmsStandardDataResult omsStandardDataResult = null;
        QueryStandardDataBySmallStartAndBigEndDetailReq queryStandardDataBySmallStartAndBigEndDetailReq = new QueryStandardDataBySmallStartAndBigEndDetailReq();
        if (reqDto != null) {
            queryStandardDataBySmallStartAndBigEndDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2021841_1
            queryStandardDataBySmallStartAndBigEndDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:2021842_1
            queryStandardDataBySmallStartAndBigEndDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:2021843_1
            queryStandardDataBySmallStartAndBigEndDetailReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2021844_1
            queryStandardDataBySmallStartAndBigEndDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:2021845_1
            queryStandardDataBySmallStartAndBigEndDetailReq.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:2021846_1
            queryStandardDataBySmallStartAndBigEndDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:2021847_1
        }

        /*4-01-01查询标准数据详情by小于等于开始时间大于等于结束时间[10277]   */

        omsStandardDataResult = mOmsStandardDataResultService.queryStandardDataBySmallStartAndBigEndDetail(queryStandardDataBySmallStartAndBigEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsStandardDataResult_1 = omsStandardDataResult;

        QueryStandardDataBySmallStartAndBigEndDetailComRespDto retData = new QueryStandardDataBySmallStartAndBigEndDetailComRespDto();
        if (omsStandardDataResult_1 != null) {
            retData.setDataResultId(omsStandardDataResult_1.getDataResultId());//SimpleFieldAssign//sourceId:2021858_1
            retData.setDataResult(omsStandardDataResult_1.getDataResult());//SimpleFieldAssign//sourceId:2021859_1
        }


        return retData;
    }

    /**
     * D4执行当前内容或兄弟计算修订异常场景(公共)[10288]
     * gen by moon at 3/8/2025, 12:06:29 AM
     */
    @Trace(operationName = "D4执行当前内容或兄弟计算修订异常场景(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCurConBrotherCalcReviseAnormalSceneComRespDto implementCurConBrotherCalcReviseAnormalSceneCom(ImplementCurConBrotherCalcReviseAnormalSceneComReqDto reqDto) {


        if ((reqDto != null && reqDto.getDataCalcNormalAbnormal() != null && reqDto.getDataCalcNormalAbnormal().equals("ABNORMAL_SCENE"))) {
            //if(D4执行当前内容或兄弟计算修订异常场景(公共).数据计算正常与异常场景 等于 异常场景)  73368

            QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = null;
            QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto = new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2024862_1_73370
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2024863_1_73370
            if (reqDto != null) {
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2025259_1_73370
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2024864_1_73370
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2024869_1_73370
            }

            /*D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)[9935]   */
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getCycleStartTime(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-周期开始时间不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaluationTemplateId(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjEntityId(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTypeCode(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象类型编码不能为空", false);
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            ImplementLoopCalcCyclesStandardDataComRespDto implementLoopCalcCyclesStandardDataComRespDto = null;
            if (queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto != null) {
                ImplementLoopCalcCyclesStandardDataComReqDto implementLoopCalcCyclesStandardDataComReqDto = new ImplementLoopCalcCyclesStandardDataComReqDto();
                if (reqDto != null) {
                    implementLoopCalcCyclesStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2025246_1_73374
                    implementLoopCalcCyclesStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2025247_1_73374
                    implementLoopCalcCyclesStandardDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2025248_1_73374
                }
                if (queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto != null && queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList() != null && !CollectionUtil.isEmpty(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList())) {
                    implementLoopCalcCyclesStandardDataComReqDto.setTargetBelongCycleList(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList().stream().map(item -> BeanUtil.toBean(item, com.wicket.okrcalc.biz.service.dto.common.TargetBelongCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2025245_1_73374
                }

                /*D4执行循环计算不同周期标准数据异常或修订场景(公共)[10290]   */
                Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto.getEventBatchUpdateCode(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-事务内数据更新批次标识不能为空", false);
                Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto.getCalcStartTime(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-计算开始时间不能为空", false);
                Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto.getTargetScoreUnit(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-目标得分单位不能为空", false);
                implementLoopCalcCyclesStandardDataComRespDto = implementLoopCalcCyclesStandardDataCom(implementLoopCalcCyclesStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;


            }
        } else if ((reqDto != null && reqDto.getDataCalcNormalAbnormal() != null && reqDto.getDataCalcNormalAbnormal().equals("REVISE_ABNORMAL_SCENE") && reqDto != null && reqDto.getParentEvaObjTargetCycleId() != null)) {
            //elseif((D4执行当前内容或兄弟计算修订异常场景(公共).数据计算正常与异常场景 等于 修订异常场景 and D4执行当前内容或兄弟计算修订异常场景(公共).上级被评对象目标周期标识 值不等于空 ))  73369

            QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 = null;
            QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1 = new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2024862_1_73371
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2024863_1_73371
            if (reqDto != null) {
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2024871_1_73371
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2024864_1_73371
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2024869_1_73371
            }

            /*D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)[9935]   */
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getCycleStartTime(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-周期开始时间不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaluationTemplateId(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaObjEntityId(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaObjTypeCode(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象类型编码不能为空", false);
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            ImplementLoopCalcCyclesStandardDataComRespDto implementLoopCalcCyclesStandardDataComRespDto_1 = null;
            if (queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 != null) {
                ImplementLoopCalcCyclesStandardDataComReqDto implementLoopCalcCyclesStandardDataComReqDto_1 = new ImplementLoopCalcCyclesStandardDataComReqDto();
                if (reqDto != null) {
                    implementLoopCalcCyclesStandardDataComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2025246_1_73375
                    implementLoopCalcCyclesStandardDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2025247_1_73375
                    implementLoopCalcCyclesStandardDataComReqDto_1.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2025248_1_73375
                }
                if (queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 != null && queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList() != null && !CollectionUtil.isEmpty(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList())) {
                    implementLoopCalcCyclesStandardDataComReqDto_1.setTargetBelongCycleList(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList().stream().map(item -> BeanUtil.toBean(item, com.wicket.okrcalc.biz.service.dto.common.TargetBelongCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2025245_1_73375
                }

                /*D4执行循环计算不同周期标准数据异常或修订场景(公共)[10290]   */
                Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto_1.getEventBatchUpdateCode(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-事务内数据更新批次标识不能为空", false);
                Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto_1.getCalcStartTime(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-计算开始时间不能为空", false);
                Assert.isNull(implementLoopCalcCyclesStandardDataComReqDto_1.getTargetScoreUnit(), "D4执行当前内容或兄弟计算修订异常场景(公共)-D4执行循环计算不同周期标准数据异常或修订场景(公共)-目标得分单位不能为空", false);
                implementLoopCalcCyclesStandardDataComRespDto_1 = implementLoopCalcCyclesStandardDataCom(implementLoopCalcCyclesStandardDataComReqDto_1)/*vcase invoke 同服务,同domain*/;


            }
        }
        ImplementCurConBrotherCalcReviseAnormalSceneComRespDto retData = new ImplementCurConBrotherCalcReviseAnormalSceneComRespDto();


        return retData;
    }

    /**
     * D4执行父级内容向上计算(公共)[10289]
     * gen by moon at 3/8/2025, 12:06:27 AM
     */
    @Trace(operationName = "D4执行父级内容向上计算(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementParentConUpCalcComRespDto implementParentConUpCalcCom(ImplementParentConUpCalcComReqDto reqDto) {


        //virtualUsage D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)  73377
        QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = null;
        QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto = new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
        queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2025485_1_73377
        queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2025486_1_73377
        if (reqDto != null) {
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2025496_1_73377
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2025487_1_73377
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2025492_1_73377
        }

        /*D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)[9935]   */
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTargetCycleCode(), "D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-被评对象目标周期标识不能为空", false);
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getCycleStartTime(), "D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-周期开始时间不能为空", false);
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaluationTemplateId(), "D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjEntityId(), "D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTypeCode(), "D4执行父级内容向上计算(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-主树被评对象类型编码不能为空", false);
        queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage M4执行目标归属周期【循环开始】  73378
        //ModelCode: circulationCollections
        for (com.wicket.okrapp.integration.dto.TargetBelongCycleDto circulationCollectionsRes : queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList()) {

//virtualUsage D4-1查标准数据详情(公共)  73570
            QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
            QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto = new QueryStandardDataDetailComReqDto();
            queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2025588_1_73570
            if (circulationCollectionsRes != null) {
                queryStandardDataDetailComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2025587_1_73570
                queryStandardDataDetailComReqDto.setThemeContentId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2026166_1_73570
            }

            /*D4-1查标准数据详情(公共)[2695]   */
            Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(), "D4执行父级内容向上计算(公共)-D4-1查标准数据详情(公共)-周期ID不能为空", false);
            Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(), "D4执行父级内容向上计算(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空", false);
            Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(), "D4执行父级内容向上计算(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空", false);
            queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;


            if ((queryStandardDataDetailComRespDto != null && queryStandardDataDetailComRespDto.getDataResultId() != null)) {
                //if(D4-1查标准数据详情(公共).数据结果ID  值不等于空 )  73571

                ImplementCalcCurAndAncestorPlanStandardDataComRespDto implementCalcCurAndAncestorPlanStandardDataComRespDto = null;
                ImplementCalcCurAndAncestorPlanStandardDataComReqDto implementCalcCurAndAncestorPlanStandardDataComReqDto = new ImplementCalcCurAndAncestorPlanStandardDataComReqDto();
                implementCalcCurAndAncestorPlanStandardDataComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2025383_1_73572
                implementCalcCurAndAncestorPlanStandardDataComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2025384_1_73572
                if (circulationCollectionsRes != null) {
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setPreUpdateCycleId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2025387_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2025388_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setUpdateCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:2025389_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setUpdateCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:2025390_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setUpdateCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:2025391_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:2025395_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setEvaObjTargetCycleCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2025385_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType() != null ? String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()) : "");//SimpleFieldAssign//sourceId:2025386_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2025382_1_73572
                }
                if (reqDto != null) {
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2025392_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2025393_1_73572
                    implementCalcCurAndAncestorPlanStandardDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2025394_1_73572
                }

                /*D4执行计算当前及祖先规划标准数据(公共)[9724]   */
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getUpdateCycleId(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期ID不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getUpdateCycleStartTime(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期开始时间不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getUpdateCycleEndTime(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期结束时间不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getUpdateCycleTypeCode(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期类型标识不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getIsLastCycle(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-更新周期是否末级周期不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEvaObjEntityId(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-主树被评对象内容表主键ID不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEvaObjTypeCode(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-主树被评对象类型编码不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEvaObjTargetCycleCode(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-被评对象目标周期标识不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getParentSubMidCycleType(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-父子中过程周期类型不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEvaluationTemplateId(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getEventBatchUpdateCode(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-事务内数据更新批次标识不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getCalcStartTime(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-计算开始时间不能为空", false);
                Assert.isNull(implementCalcCurAndAncestorPlanStandardDataComReqDto.getTargetScoreUnit(), "D4执行父级内容向上计算(公共)-D4执行计算当前及祖先规划标准数据(公共)-目标得分单位不能为空", false);
                implementCalcCurAndAncestorPlanStandardDataComRespDto = targetCalcService.implementCalcCurAndAncestorPlanStandardDataCom(implementCalcCurAndAncestorPlanStandardDataComReqDto)/*vcase invoke isSameApp*/;


            }
//virtualUsage M4-执行【循环结束】  73379
            //ModelCode: circulationEnd
        }

        ImplementParentConUpCalcComRespDto retData = new ImplementParentConUpCalcComRespDto();


        return retData;
    }

    /**
     * D4执行循环计算不同周期标准数据异常或修订场景(公共)[10290]
     * gen by moon at 12/3/2024, 11:40:21 AM
     */
    @Trace(operationName = "D4执行循环计算不同周期标准数据异常或修订场景(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementLoopCalcCyclesStandardDataComRespDto implementLoopCalcCyclesStandardDataCom(ImplementLoopCalcCyclesStandardDataComReqDto reqDto) {


        //virtualUsage M4执行目标归属周期【循环开始】  73363
        //ModelCode: circulationCollections
        for (com.wicket.okrcalc.biz.service.dto.common.TargetBelongCycleDto circulationCollectionsRes : reqDto.getTargetBelongCycleList()) {

//virtualUsage D4-1查标准数据详情(公共)  73364
            QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
            com.wicket.okrcalc.biz.service.dto.req.QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto = new QueryStandardDataDetailComReqDto();
            queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2025238_1_73364
            if (circulationCollectionsRes != null) {
                queryStandardDataDetailComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2025236_1_73364
                queryStandardDataDetailComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:2025237_1_73364
            }

            /*D4-1查标准数据详情(公共)[2695]   */
            Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-周期ID不能为空", false);
            Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空", false);
            Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空", false);
            queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;


            if ((queryStandardDataDetailComRespDto != null && queryStandardDataDetailComRespDto.getDataResultId() != null)) {
                //if(D4-1查当前内容当前周期当前有效的标准数据（用于判断需不需要进入计算）.数据结果ID  值不等于空 )  73365

                ImplementCurOrAncestorContentCalcStandardDataComRespDto implementCurOrAncestorContentCalcStandardDataComRespDto = null;
                ImplementCurOrAncestorContentCalcStandardDataComReqDto implementCurOrAncestorContentCalcStandardDataComReqDto = new ImplementCurOrAncestorContentCalcStandardDataComReqDto();
                implementCurOrAncestorContentCalcStandardDataComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2025370_1_73376
                if (circulationCollectionsRes != null) {
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setLastCycleCalcModelId(circulationCollectionsRes.getLastCycleCalcModelId());//SimpleFieldAssign//sourceId:2025360_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setProcessCycleCalcModelId(circulationCollectionsRes.getProcessCycleCalcModelId());//SimpleFieldAssign//sourceId:2025361_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setSubCycleCalcModelId(circulationCollectionsRes.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:2025362_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setMidCycleCalcModelId(circulationCollectionsRes.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:2025363_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setParentCycleCalcModelId(circulationCollectionsRes.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:2025364_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setPreUpdateCycleId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2025365_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2025366_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setUpdateCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:2025367_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setUpdateCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:2025368_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setUpdateCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:2025369_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:2025374_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2025375_1_73376
                }
                if (reqDto != null) {
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2025371_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2025372_1_73376
                    implementCurOrAncestorContentCalcStandardDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2025373_1_73376
                }

                /*D4执行当前或祖先内容计算目标标准数据(公共)[9733]   */
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getUpdateCycleId(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期ID不能为空", false);
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getUpdateCycleStartTime(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期开始时间不能为空", false);
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getUpdateCycleEndTime(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期结束时间不能为空", false);
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getUpdateCycleTypeCode(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期类型标识不能为空", false);
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getIsLastCycle(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-更新周期是否末级周期不能为空", false);
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getEvaluationTemplateId(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getSpaceId(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-创建于空间ID不能为空", false);
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getEventBatchUpdateCode(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-事务内数据更新批次标识不能为空", false);
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getCalcStartTime(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-计算开始时间不能为空", false);
                Assert.isNull(implementCurOrAncestorContentCalcStandardDataComReqDto.getTargetScoreUnit(), "D4执行循环计算不同周期标准数据异常或修订场景(公共)-D4执行当前或祖先内容计算目标标准数据(公共)-目标得分单位不能为空", false);
                implementCurOrAncestorContentCalcStandardDataComRespDto = targetCalcService.implementCurOrAncestorContentCalcStandardDataCom(implementCurOrAncestorContentCalcStandardDataComReqDto)/*vcase invoke isSameApp*/;


            }
//virtualUsage M4-执行【循环结束】  73367
            //ModelCode: circulationEnd
        }

        ImplementLoopCalcCyclesStandardDataComRespDto retData = new ImplementLoopCalcCyclesStandardDataComRespDto();


        return retData;
    }

    /**
     * D4分析数据计算正常与异常场景(公共)[10291]
     * gen by moon at 10/30/2024, 10:06:22 PM
     */
    @Trace(operationName = "D4分析数据计算正常与异常场景(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AnalysisDataCalcNormalAndAmSceneComRespDto analysisDataCalcNormalAndAmSceneCom(AnalysisDataCalcNormalAndAmSceneComReqDto reqDto) {


        AnalysisDataCalcNormalAmSceneComRespDto analysisDataCalcNormalAmSceneComRespDto_1 = null;
//步骤0: D3分析数据计算正常场景中的正常与异常(公共) - analysisDataCalcNormalAmSceneCom
        AnalysisDataCalcNormalAmSceneComRespDto analysisDataCalcNormalAmSceneComRespDto = null;
        AnalysisDataCalcNormalAmSceneComReqDto analysisDataCalcNormalAmSceneComReqDto = new AnalysisDataCalcNormalAmSceneComReqDto();
        if (reqDto != null) {
            analysisDataCalcNormalAmSceneComReqDto.setDataCalcNormalAbnormal(reqDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2025626_1
            analysisDataCalcNormalAmSceneComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2025623_1
            analysisDataCalcNormalAmSceneComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2025624_1
        }

        /*D3分析数据计算正常场景中的正常与异常(公共)[10284]   */
        Assert.isNull(analysisDataCalcNormalAmSceneComReqDto.getDataCalcNormalAbnormal(), "D4分析数据计算正常与异常场景(公共)-D3分析数据计算正常场景中的正常与异常(公共)-数据计算正常与异常场景不能为空", false);
        Assert.isNull(analysisDataCalcNormalAmSceneComReqDto.getCycleId(), "D4分析数据计算正常与异常场景(公共)-D3分析数据计算正常场景中的正常与异常(公共)-周期ID不能为空", false);
        Assert.isNull(analysisDataCalcNormalAmSceneComReqDto.getEvaluationTemplateId(), "D4分析数据计算正常与异常场景(公共)-D3分析数据计算正常场景中的正常与异常(公共)-冗余评价模板ID不能为空", false);
        analysisDataCalcNormalAmSceneComRespDto = fwAppEvaCalcClient.analysisDataCalcNormalAmSceneCom(analysisDataCalcNormalAmSceneComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        analysisDataCalcNormalAmSceneComRespDto_1 = analysisDataCalcNormalAmSceneComRespDto;

        AnalysisDataCalcNormalAndAmSceneComRespDto retData = new AnalysisDataCalcNormalAndAmSceneComRespDto();
        if (analysisDataCalcNormalAmSceneComRespDto_1 != null) {
            retData.setDataCalcNormalAbnormal(analysisDataCalcNormalAmSceneComRespDto_1.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2025630_1
        }


        return retData;
    }

    /**
     * D4执行计算克隆向右非末级周期标准数据(公共)[10415]
     * gen by moon at 12/5/2024, 11:01:31 PM
     */
    @Trace(operationName = "D4执行计算克隆向右非末级周期标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCalcCurRightCycleStandardDataComRespDto implementCalcCurRightCycleStandardDataCom(ImplementCalcCurRightCycleStandardDataComReqDto reqDto) {


        ImplementCalcReceivingField006RespDto receptionServiceRes_1 = null;
//virtualUsage D3分析克隆非末级周期进入条件(公共)  73648
        AnalysisCloneNoLastCycleEnterConditionComRespDto analysisCloneNoLastCycleEnterConditionComRespDto = null;
        AnalysisCloneNoLastCycleEnterConditionComReqDto analysisCloneNoLastCycleEnterConditionComReqDto = new AnalysisCloneNoLastCycleEnterConditionComReqDto();
        if (reqDto != null) {
            analysisCloneNoLastCycleEnterConditionComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033288_1_73648
            analysisCloneNoLastCycleEnterConditionComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2033289_1_73648
            analysisCloneNoLastCycleEnterConditionComReqDto.setOwnEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033290_1_73648
            analysisCloneNoLastCycleEnterConditionComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033291_1_73648
        }

        /*D3分析克隆非末级周期进入条件(公共)[10416]   */
        Assert.isNull(analysisCloneNoLastCycleEnterConditionComReqDto.getUpdateCycleId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3分析克隆非末级周期进入条件(公共)-更新周期ID不能为空", false);
        Assert.isNull(analysisCloneNoLastCycleEnterConditionComReqDto.getCycleId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3分析克隆非末级周期进入条件(公共)-归属周期ID不能为空", false);
        Assert.isNull(analysisCloneNoLastCycleEnterConditionComReqDto.getOwnEntityId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3分析克隆非末级周期进入条件(公共)-归属内容表主键ID不能为空", false);
        Assert.isNull(analysisCloneNoLastCycleEnterConditionComReqDto.getEvaluationTemplateId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3分析克隆非末级周期进入条件(公共)-冗余评价模板ID不能为空", false);
        analysisCloneNoLastCycleEnterConditionComRespDto = fwAppEvaCalcClient.analysisCloneNoLastCycleEnterConditionCom(analysisCloneNoLastCycleEnterConditionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((analysisCloneNoLastCycleEnterConditionComRespDto != null && analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType() != null && analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType().equals("RECYCLE_CLONE"))) {
            //if(D3分析克隆非末级周期进入条件(公共).非末级周期克隆类型 等于 最近可循环克隆)  73649

            CalculateFinalObjectiveScoreComRespDto calculateFinalObjectiveScoreComRespDto = null;
            CalculateFinalObjectiveScoreComReqDto calculateFinalObjectiveScoreComReqDto = new CalculateFinalObjectiveScoreComReqDto();
            calculateFinalObjectiveScoreComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2033493_1_73665
            if (reqDto != null) {
                calculateFinalObjectiveScoreComReqDto.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:2033503_1_73665
                calculateFinalObjectiveScoreComReqDto.setReportScoreCountFormula(reqDto.getReportScoreCountFormula());//SimpleFieldAssign//sourceId:2033494_1_73665
                calculateFinalObjectiveScoreComReqDto.setSubAndObjModel(reqDto.getSubAndObjModel());//SimpleFieldAssign//sourceId:2033490_1_73665
                calculateFinalObjectiveScoreComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033504_1_73665
                calculateFinalObjectiveScoreComReqDto.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033505_1_73665
                calculateFinalObjectiveScoreComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:2033496_1_73665
                calculateFinalObjectiveScoreComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:2033495_1_73665
                calculateFinalObjectiveScoreComReqDto.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:2033491_1_73665
                calculateFinalObjectiveScoreComReqDto.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:2033501_1_73665
                calculateFinalObjectiveScoreComReqDto.setEvaTargetStartValue(reqDto.getEvaTargetStartValue());//SimpleFieldAssign//sourceId:2033498_1_73665
                calculateFinalObjectiveScoreComReqDto.setEvaTargetValue(reqDto.getEvaTargetValue());//SimpleFieldAssign//sourceId:2033499_1_73665
                calculateFinalObjectiveScoreComReqDto.setEvaTargetDiagnosticValue(reqDto.getEvaTargetDiagnosticValue());//SimpleFieldAssign//sourceId:2033500_1_73665
                calculateFinalObjectiveScoreComReqDto.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:2033497_1_73665
                calculateFinalObjectiveScoreComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033492_1_73665
            }

            /*D3计算指标最终客观得分(公共)[9442]   */
            Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetAttributionCycleId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-目标归属周期ID不能为空", false);
            Assert.isNull(calculateFinalObjectiveScoreComReqDto.getUpdateCycleId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-更新周期ID不能为空", false);
            Assert.isNull(calculateFinalObjectiveScoreComReqDto.getEvaObjTargetCycleId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetCycleContentTypeCode(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容类型编码不能为空", false);
            Assert.isNull(calculateFinalObjectiveScoreComReqDto.getTargetCycleContentId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容ID不能为空", false);
            Assert.isNull(calculateFinalObjectiveScoreComReqDto.getWeightScore(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-权重分值不能为空", false);
            Assert.isNull(calculateFinalObjectiveScoreComReqDto.getEvaluationTemplateId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(calculateFinalObjectiveScoreComReqDto.getSpaceId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-创建于空间ID不能为空", false);
            calculateFinalObjectiveScoreComRespDto = fwAppTargetCalcClient.calculateFinalObjectiveScoreCom(calculateFinalObjectiveScoreComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
            ImplementCalcReceivingField006RespDto receptionServiceRes = null;
            if (calculateFinalObjectiveScoreComRespDto != null) {
                ImplementCalcReceivingField006ReqDto receptionServiceReq = new ImplementCalcReceivingField006ReqDto();
                if (reqDto != null) {
                    receptionServiceReq.setProgressValue(reqDto.getProgressValue());//SimpleFieldAssign//sourceId:2033381_1_73655
                    receptionServiceReq.setActualValue(reqDto.getActualValue());//SimpleFieldAssign//sourceId:2033382_1_73655
                }
                if (calculateFinalObjectiveScoreComRespDto != null) {
                    receptionServiceReq.setObjectiveScore(calculateFinalObjectiveScoreComRespDto.getObjectiveScore());//SimpleFieldAssign//sourceId:2033506_1_73655
                }

                /*M4接收出参字段：进度值、实际值、客观得分[9540]  用于特殊方法接收上游入参。 */

                receptionServiceRes = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((analysisCloneNoLastCycleEnterConditionComRespDto != null && analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType() != null && analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType().equals("ACTUAL_CLONE"))) {
            //elseif(D3分析克隆非末级周期进入条件(公共).非末级周期克隆类型 等于 提前实际验收克隆)  73652

            QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto = null;
            QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto = new QueryStandardDataOfObjectDetailComReqDto();
            queryStandardDataOfObjectDetailComReqDto.setDataType("PROGRESS_VALUE");//sourceId:2033405_1_73656
            queryStandardDataOfObjectDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2033422_1_73656
            queryStandardDataOfObjectDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2033427_1_73656
            if (reqDto != null) {
                queryStandardDataOfObjectDetailComReqDto.setPeriodId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033406_1_73656
                queryStandardDataOfObjectDetailComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033409_1_73656
                queryStandardDataOfObjectDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033410_1_73656
            }

            /*D4查询进度值归属主体标准数据详情(公共)[8850]   */
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataType(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-数据点类型不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getPeriodId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-周期ID不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getEntityId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-归属内容表主键ID不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getThemeContentId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-主题内容ID不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataUsageSceneCode(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-数据业务场景不能为空", false);
            Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getSubjectLifeCycle(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询进度值归属主体标准数据详情(公共)-主体生命周期不能为空", false);
            queryStandardDataOfObjectDetailComRespDto = standardDataService.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto)/*vcase invoke isSameApp*/;


            if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
                //if(D4执行克隆向右非末级周期标准数据(公共).关联目标内容类型编码 等于 指标)  73659

                QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto_2 = null;
                QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto_1 = new QueryStandardDataOfObjectDetailComReqDto();
                queryStandardDataOfObjectDetailComReqDto_1.setDataType("ACTUAL_VALUE");//sourceId:2033440_1_73660
                queryStandardDataOfObjectDetailComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:2033457_1_73660
                queryStandardDataOfObjectDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2033462_1_73660
                if (reqDto != null) {
                    queryStandardDataOfObjectDetailComReqDto_1.setPeriodId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033441_1_73660
                    queryStandardDataOfObjectDetailComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033477_1_73660
                    queryStandardDataOfObjectDetailComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033445_1_73660
                }

                /*D4查询实际值归属主体标准数据详情(公共)[8850]   */
                Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getDataType(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-数据点类型不能为空", false);
                Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getPeriodId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-周期ID不能为空", false);
                Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getEntityId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-归属内容表主键ID不能为空", false);
                Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getThemeContentId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-主题内容ID不能为空", false);
                Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getDataUsageSceneCode(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-数据业务场景不能为空", false);
                Assert.isNull(queryStandardDataOfObjectDetailComReqDto_1.getSubjectLifeCycle(), "D4执行计算克隆向右非末级周期标准数据(公共)-D4查询实际值归属主体标准数据详情(公共)-主体生命周期不能为空", false);
                queryStandardDataOfObjectDetailComRespDto_2 = standardDataService.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto_1)/*vcase invoke isSameApp*/;


                CalculateFinalObjectiveScoreComRespDto calculateFinalObjectiveScoreComRespDto_2 = null;
                if (queryStandardDataOfObjectDetailComRespDto_2 != null) {
                    CalculateFinalObjectiveScoreComReqDto calculateFinalObjectiveScoreComReqDto_1 = new CalculateFinalObjectiveScoreComReqDto();
                    calculateFinalObjectiveScoreComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2033493_1_73664
                    if (reqDto != null) {
                        calculateFinalObjectiveScoreComReqDto_1.setTargetAttributionCycleId(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:2033503_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setReportScoreCountFormula(reqDto.getReportScoreCountFormula());//SimpleFieldAssign//sourceId:2033494_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setSubAndObjModel(reqDto.getSubAndObjModel());//SimpleFieldAssign//sourceId:2033490_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2033504_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setEvaObjTargetCycleId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:2033505_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:2033496_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:2033495_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:2033491_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setEvaTargetStartValue(reqDto.getEvaTargetStartValue());//SimpleFieldAssign//sourceId:2033498_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setEvaTargetValue(reqDto.getEvaTargetValue());//SimpleFieldAssign//sourceId:2033499_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setEvaTargetDiagnosticValue(reqDto.getEvaTargetDiagnosticValue());//SimpleFieldAssign//sourceId:2033500_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setWeightScore(reqDto.getWeightScore());//SimpleFieldAssign//sourceId:2033497_1_73664
                        calculateFinalObjectiveScoreComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2033492_1_73664
                    }
                    if (queryStandardDataOfObjectDetailComRespDto_2 != null) {
                        calculateFinalObjectiveScoreComReqDto_1.setActualValue(queryStandardDataOfObjectDetailComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:2033501_1_73664
                    }

                    /*D3计算指标最终客观得分(公共)[9442]   */
                    Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getTargetAttributionCycleId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-目标归属周期ID不能为空", false);
                    Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getUpdateCycleId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-更新周期ID不能为空", false);
                    Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getEvaObjTargetCycleId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-被评对象目标周期ID不能为空", false);
                    Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getTargetCycleContentTypeCode(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容类型编码不能为空", false);
                    Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getTargetCycleContentId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-关联目标内容ID不能为空", false);
                    Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getWeightScore(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-权重分值不能为空", false);
                    Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getEvaluationTemplateId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-冗余评价模板ID不能为空", false);
                    Assert.isNull(calculateFinalObjectiveScoreComReqDto_1.getSpaceId(), "D4执行计算克隆向右非末级周期标准数据(公共)-D3计算指标最终客观得分(公共)-创建于空间ID不能为空", false);
                    calculateFinalObjectiveScoreComRespDto_2 = fwAppTargetCalcClient.calculateFinalObjectiveScoreCom(calculateFinalObjectiveScoreComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//ModelCode: receptionService
                ImplementCalcReceivingField006RespDto receptionServiceRes_2 = null;
                if (queryStandardDataOfObjectDetailComRespDto != null && queryStandardDataOfObjectDetailComRespDto_2 != null && calculateFinalObjectiveScoreComRespDto_2 != null) {
                    ImplementCalcReceivingField006ReqDto receptionServiceReq_1 = new ImplementCalcReceivingField006ReqDto();
                    if (queryStandardDataOfObjectDetailComRespDto != null) {
                        receptionServiceReq_1.setProgressValue(queryStandardDataOfObjectDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:2033381_1_73663
                    }
                    if (queryStandardDataOfObjectDetailComRespDto_2 != null) {
                        receptionServiceReq_1.setActualValue(queryStandardDataOfObjectDetailComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:2033382_1_73663
                    }
                    if (calculateFinalObjectiveScoreComRespDto_2 != null) {
                        receptionServiceReq_1.setObjectiveScore(calculateFinalObjectiveScoreComRespDto_2.getObjectiveScore());//SimpleFieldAssign//sourceId:2033506_1_73663
                    }

                    /*M4接收出参字段：进度值、实际值、客观得分[9540]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_2 = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq_1);


                    receptionServiceRes_1 = receptionServiceRes_2;
                }
            } else if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET") || reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))) {
                //elseif((D4执行克隆向右非末级周期标准数据(公共).关联目标内容类型编码 等于 目标 or D4执行克隆向右非末级周期标准数据(公共).关联目标内容类型编码 等于 目标分类))  73661

//ModelCode: receptionService
                ImplementCalcReceivingField006RespDto receptionServiceRes_3 = null;
                if (queryStandardDataOfObjectDetailComRespDto != null) {
                    ImplementCalcReceivingField006ReqDto receptionServiceReq_2 = new ImplementCalcReceivingField006ReqDto();
                    if (queryStandardDataOfObjectDetailComRespDto != null) {
                        receptionServiceReq_2.setProgressValue(queryStandardDataOfObjectDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:2033381_1_73662
                    }

                    /*M4接收出参字段：进度值、实际值、客观得分[9540]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_3 = nbEvaCalc.implementCalcReceivingField006(receptionServiceReq_2);


                    receptionServiceRes_1 = receptionServiceRes_3;
                }
            }
        } else if ((analysisCloneNoLastCycleEnterConditionComRespDto != null && analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType() != null && analysisCloneNoLastCycleEnterConditionComRespDto.getCycleCloneType().equals("NO_CLONE"))) {
            //elseif(D3分析克隆非末级周期进入条件(公共).非末级周期克隆类型 等于 不克隆)  73653

//processBranchName:正常结束 ,processBranchId:73654

        }
        ImplementCalcCurRightCycleStandardDataComRespDto retData = new ImplementCalcCurRightCycleStandardDataComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setProgressValue(receptionServiceRes_1.getProgressValue());//SimpleFieldAssign//sourceId:2033484_1
            retData.setActualValue(receptionServiceRes_1.getActualValue());//SimpleFieldAssign//sourceId:2033485_1
            retData.setObjectiveScore(receptionServiceRes_1.getObjectiveScore());//SimpleFieldAssign//sourceId:2033531_1
        }


        return retData;
    }

    /**
     * D4执行MQ计算当前或祖先规划目标标准数据(公共)[10501]
     * gen by moon at 3/6/2025, 10:13:58 PM
     */
    @Trace(operationName = "D4执行MQ计算当前或祖先规划目标标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCalcCurOrParentTargetDataComRespDto implementCalcCurOrParentTargetDataCom(ImplementCalcCurOrParentTargetDataComReqDto reqDto) {


        if ((reqDto != null && reqDto.getLastCycleCalcModelId() != null)) {
            //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).末级周期计算模型ID 值不等于空 )  73886

            ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto = null;
            ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto = new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
            if (reqDto != null) {
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setTargetAttributionCycleId(reqDto.getLastCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73895
                implementEvaObjCurrentAndSupCountFormulasComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73895
            }

            /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getTargetAttributionCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getUpdateCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getUpdateCycleStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getUpdateCycleEndTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getUpdateCycleTypeCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getIsLastCycle(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getSpaceId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getEventBatchUpdateCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getCalcStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto.getTargetScoreUnit(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空", false);
            implementEvaObjCurrentAndSupCountFormulasComRespDto = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto)/*vcase invoke isSameApp*/;


        }
        if ((reqDto != null && reqDto.getProcessCycleCalcModelId() != null)) {
            //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).过程中间周期计算模型ID 值不等于空 )  73888

            ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto_1 = null;
            ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto_1 = new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
            if (reqDto != null) {
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setTargetAttributionCycleId(reqDto.getProcessCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73896
                implementEvaObjCurrentAndSupCountFormulasComReqDto_1.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73896
            }

            /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getTargetAttributionCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getUpdateCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getUpdateCycleStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getUpdateCycleEndTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getUpdateCycleTypeCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getIsLastCycle(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getSpaceId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getEventBatchUpdateCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getCalcStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_1.getTargetScoreUnit(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空", false);
            implementEvaObjCurrentAndSupCountFormulasComRespDto_1 = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto_1)/*vcase invoke isSameApp*/;


        }
        if ((reqDto != null && reqDto.getSubCycleCalcModelId() != null)) {
            //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).子周期计算模型ID 值不等于空 )  73890

            ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto_2 = null;
            ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto_2 = new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
            if (reqDto != null) {
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setTargetAttributionCycleId(reqDto.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73897
                implementEvaObjCurrentAndSupCountFormulasComReqDto_2.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73897
            }

            /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getTargetAttributionCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getUpdateCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getUpdateCycleStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getUpdateCycleEndTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getUpdateCycleTypeCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getIsLastCycle(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getSpaceId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getEventBatchUpdateCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getCalcStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_2.getTargetScoreUnit(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空", false);
            implementEvaObjCurrentAndSupCountFormulasComRespDto_2 = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto_2)/*vcase invoke isSameApp*/;


        }
        if ((reqDto != null && reqDto.getMidCycleCalcModelId() != null)) {
            //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).中期计算模型ID 值不等于空 )  73892

            ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto_3 = null;
            ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto_3 = new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
            if (reqDto != null) {
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setTargetAttributionCycleId(reqDto.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73898
                implementEvaObjCurrentAndSupCountFormulasComReqDto_3.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73898
            }

            /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getTargetAttributionCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getUpdateCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getUpdateCycleStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getUpdateCycleEndTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getUpdateCycleTypeCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getIsLastCycle(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getSpaceId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getEventBatchUpdateCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getCalcStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_3.getTargetScoreUnit(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空", false);
            implementEvaObjCurrentAndSupCountFormulasComRespDto_3 = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto_3)/*vcase invoke isSameApp*/;


        }
        if ((reqDto != null && reqDto.getParentCycleCalcModelId() != null)) {
            //if(D4执行MQ计算当前或祖先规划目标标准数据(公共).父周期计算模型ID 值不等于空 )  73894

            ImplementEvaObjCurrentAndSupCountFormulasComRespDto implementEvaObjCurrentAndSupCountFormulasComRespDto_4 = null;
            ImplementEvaObjCurrentAndSupCountFormulasComReqDto implementEvaObjCurrentAndSupCountFormulasComReqDto_4 = new ImplementEvaObjCurrentAndSupCountFormulasComReqDto();
            if (reqDto != null) {
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setTargetAttributionCycleId(reqDto.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:2040252_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040260_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040253_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040254_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040255_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040256_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040261_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2040251_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040257_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040258_1_73899
                implementEvaObjCurrentAndSupCountFormulasComReqDto_4.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040259_1_73899
            }

            /*D4执行评价对象树当前与上级公式计算(公共)[8736]   */
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getTargetAttributionCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标归属周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getUpdateCycleId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getUpdateCycleStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getUpdateCycleEndTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期结束时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getUpdateCycleTypeCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-更新周期类型标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getIsLastCycle(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-是否末级周期不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getSpaceId(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-创建于空间ID不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getEventBatchUpdateCode(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-事务内数据更新批次标识不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getCalcStartTime(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-计算开始时间不能为空", false);
            Assert.isNull(implementEvaObjCurrentAndSupCountFormulasComReqDto_4.getTargetScoreUnit(), "D4执行MQ计算当前或祖先规划目标标准数据(公共)-D4执行评价对象树当前与上级公式计算(公共)-目标得分单位不能为空", false);
            implementEvaObjCurrentAndSupCountFormulasComRespDto_4 = targetCalcService.implementEvaObjCurrentAndSupCountFormulasCom(implementEvaObjCurrentAndSupCountFormulasComReqDto_4)/*vcase invoke isSameApp*/;


        }
        ImplementCalcCurOrParentTargetDataComRespDto retData = new ImplementCalcCurOrParentTargetDataComRespDto();


        return retData;
    }

    /**
     * D4执行MQ计算当前及祖先规划目标标准数据(公共)[10502]
     * gen by moon at 3/8/2025, 4:16:21 PM
     */
    @Trace(operationName = "D4执行MQ计算当前及祖先规划目标标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCalcCurAndParentTargetDataComRespDto implementCalcCurAndParentTargetDataCom(ImplementCalcCurAndParentTargetDataComReqDto reqDto) {


        //步骤0: D4执行计算公共接收字段(公共) - implementCalcReceiveFieldCom
        ImplementCalcReceiveFieldComRespDto implementCalcReceiveFieldComRespDto = null;
        ImplementCalcReceiveFieldComReqDto implementCalcReceiveFieldComReqDto = new ImplementCalcReceiveFieldComReqDto();
        if (reqDto != null) {
            implementCalcReceiveFieldComReqDto.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040295_1
            implementCalcReceiveFieldComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040296_1
            implementCalcReceiveFieldComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040297_1
            implementCalcReceiveFieldComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040298_1
            implementCalcReceiveFieldComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040299_1
            implementCalcReceiveFieldComReqDto.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040305_1
            implementCalcReceiveFieldComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2040280_1
            implementCalcReceiveFieldComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2040281_1
            implementCalcReceiveFieldComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2040282_1
            implementCalcReceiveFieldComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2040286_1
            implementCalcReceiveFieldComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040279_1
            implementCalcReceiveFieldComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040284_1
            implementCalcReceiveFieldComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040294_1
            implementCalcReceiveFieldComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040301_1
        }

        /*D4执行计算公共接收字段(公共)[9726]   */
        Assert.isNull(implementCalcReceiveFieldComReqDto.getUpdateCycleId(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-更新周期ID不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getUpdateCycleStartTime(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-更新周期开始时间不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getUpdateCycleEndTime(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-更新周期结束时间不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getUpdateCycleTypeCode(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-更新周期类型标识不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getIsLastCycle(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-是否末级周期不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getEvaObjEntityId(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-主树被评对象内容表主键ID不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getEvaObjTypeCode(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-主树被评对象类型编码不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getEvaObjTargetCycleCode(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-被评对象目标周期标识不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getParentSubMidCycleType(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-父子中过程周期类型不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getEvaluationTemplateId(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getEventBatchUpdateCode(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-事务内数据更新批次标识不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getCalcStartTime(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-计算开始时间不能为空", false);
        Assert.isNull(implementCalcReceiveFieldComReqDto.getTargetScoreUnit(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行计算公共接收字段(公共)-目标得分单位不能为空", false);
        implementCalcReceiveFieldComRespDto = divineDataService.implementCalcReceiveFieldCom(implementCalcReceiveFieldComReqDto)/*vcase invoke isSameApp*/;


//步骤1: D3查询当前及祖先列表(公共) - queryCurAndAncestorListCom
        QueryCurAndAncestorListComRespDto queryCurAndAncestorListComRespDto = null;
        QueryCurAndAncestorListComReqDto queryCurAndAncestorListComReqDto = new QueryCurAndAncestorListComReqDto();
        if (reqDto != null) {
            queryCurAndAncestorListComReqDto.setComCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2040310_1
        }

        /*D3查询当前及祖先列表(公共)[9727]   */
        Assert.isNull(queryCurAndAncestorListComReqDto.getComCode(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查询当前及祖先列表(公共)-通用编码标识不能为空", false);
        queryCurAndAncestorListComRespDto = fwAppTargetCalcClient.queryCurAndAncestorListCom(queryCurAndAncestorListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤2: D3批量查询目标归属周期by被评对象目标周期标识（双排序）(公共) - batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeCom
        BatchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComRespDto batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComRespDto = null;
        if (queryCurAndAncestorListComRespDto != null) {
            BatchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto = new BatchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto();
            if (queryCurAndAncestorListComRespDto != null) {
                batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setTargetBelongCycleList(queryCurAndAncestorListComRespDto.getCurAndAncestorList());//list-field-assign//sourceId:2040313_1
            }
            if (reqDto != null) {
                batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040318_1
                batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040319_1
                batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040320_1
                batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2040314_1
                batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2040315_1
                batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2040316_1
                batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040317_1
            }

            /*D3查当前及祖先目标归属周期列表(公共)[9730]   */
            Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getCycleStartTime(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-周期开始时间不能为空", false);
            Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getCycleEndTime(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-周期结束时间不能为空", false);
            Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getCycleTypeCode(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-周期类型标识不能为空", false);
            Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getEvaObjEntityId(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-主树被评对象内容表主键ID不能为空", false);
            Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getEvaObjTypeCode(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-主树被评对象类型编码不能为空", false);
            Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getParentSubMidCycleType(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-父子中过程周期类型不能为空", false);
            Assert.isNull(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto.getEvaluationTemplateId(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D3查当前及祖先目标归属周期列表(公共)-冗余评价模板ID不能为空", false);
            batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComRespDto = fwAppTargetCalcClient.batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeCom(batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }

//步骤3: M4执行目标归属周期【循环开始】 - implementTargetAttributionCycleLoopStart
        //ModelCode: circulationCollections
        for (com.wicket.okrapp.integration.dto.TargetBelongCycleDto circulationCollectionsRes : batchQueryTargetAttributionCycleByEvaObjTargetCycleCodeComRespDto.getTargetBelongCycleList()) {


//步骤4: D4执行MQ计算当前或祖先规划目标标准数据(公共) - implementCalcCurOrParentTargetDataCom
            ImplementCalcCurOrParentTargetDataComRespDto implementCalcCurOrParentTargetDataComRespDto = null;
            ImplementCalcCurOrParentTargetDataComReqDto implementCalcCurOrParentTargetDataComReqDto = new ImplementCalcCurOrParentTargetDataComReqDto();
            implementCalcCurOrParentTargetDataComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2040419_1
            if (circulationCollectionsRes != null) {
                implementCalcCurOrParentTargetDataComReqDto.setLastCycleCalcModelId(circulationCollectionsRes.getLastCycleCalcModelId());//SimpleFieldAssign//sourceId:2040423_1
                implementCalcCurOrParentTargetDataComReqDto.setProcessCycleCalcModelId(circulationCollectionsRes.getProcessCycleCalcModelId());//SimpleFieldAssign//sourceId:2040424_1
                implementCalcCurOrParentTargetDataComReqDto.setSubCycleCalcModelId(circulationCollectionsRes.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:2040409_1
                implementCalcCurOrParentTargetDataComReqDto.setMidCycleCalcModelId(circulationCollectionsRes.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:2040410_1
                implementCalcCurOrParentTargetDataComReqDto.setParentCycleCalcModelId(circulationCollectionsRes.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:2040411_1
            }
            if (reqDto != null) {
                implementCalcCurOrParentTargetDataComReqDto.setPreUpdateCycleId(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2040412_1
                implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2040413_1
                implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2040414_1
                implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2040415_1
                implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2040416_1
                implementCalcCurOrParentTargetDataComReqDto.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2040417_1
                implementCalcCurOrParentTargetDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040418_1
                implementCalcCurOrParentTargetDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040420_1
                implementCalcCurOrParentTargetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040421_1
                implementCalcCurOrParentTargetDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040422_1
            }

            /*D4执行MQ计算当前或祖先规划目标标准数据(公共)[10501]   */
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleId(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期ID不能为空", false);
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleStartTime(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期开始时间不能为空", false);
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleEndTime(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期结束时间不能为空", false);
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleTypeCode(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期类型标识不能为空", false);
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getIsLastCycle(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期是否末级周期不能为空", false);
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getEvaluationTemplateId(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getSpaceId(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-创建于空间ID不能为空", false);
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getEventBatchUpdateCode(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-事务内数据更新批次标识不能为空", false);
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getCalcStartTime(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-计算开始时间不能为空", false);
            Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getTargetScoreUnit(), "D4执行MQ计算当前及祖先规划目标标准数据(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-目标得分单位不能为空", false);
            implementCalcCurOrParentTargetDataComRespDto = implementCalcCurOrParentTargetDataCom(implementCalcCurOrParentTargetDataComReqDto)/*vcase invoke 同服务,同domain*/;


//步骤5: M4-执行【循环结束】 - implementLoopStopCalc
            //ModelCode: circulationEnd
        }


        ImplementCalcCurAndParentTargetDataComRespDto retData = new ImplementCalcCurAndParentTargetDataComRespDto();


        return retData;
    }

    /**
     * D4执行MQ循环计算规划目标数据异常或修订场景(公共)[10503]
     * gen by moon at 3/6/2025, 10:14:27 PM
     */
    @Trace(operationName = "D4执行MQ循环计算规划目标数据异常或修订场景(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementLoopCalcCyclesTargetDataComRespDto implementLoopCalcCyclesTargetDataCom(ImplementLoopCalcCyclesTargetDataComReqDto reqDto) {


        //virtualUsage M4执行目标归属周期【循环开始】  73903
        //ModelCode: circulationCollections
        for (TargetBelongCycleDto circulationCollectionsRes : reqDto.getTargetBelongCycleList()) {

//virtualUsage D4-1查标准数据详情(公共)  73904
            QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
            QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto = new QueryStandardDataDetailComReqDto();
            queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2040723_1_73904
            if (circulationCollectionsRes != null) {
                queryStandardDataDetailComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2040721_1_73904
                queryStandardDataDetailComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:2040722_1_73904
            }

            /*D4-1查标准数据详情(公共)[2695]   */
            Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-周期ID不能为空", false);
            Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空", false);
            Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空", false);
            queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;


            if ((queryStandardDataDetailComRespDto != null && queryStandardDataDetailComRespDto.getDataResultId() != null)) {
                //if(D4-1查当前内容当前周期当前有效的标准数据（用于判断需不需要进入计算）.数据结果ID  值不等于空 )  73905

                ImplementCalcCurOrParentTargetDataComRespDto implementCalcCurOrParentTargetDataComRespDto = null;
                ImplementCalcCurOrParentTargetDataComReqDto implementCalcCurOrParentTargetDataComReqDto = new ImplementCalcCurOrParentTargetDataComReqDto();
                implementCalcCurOrParentTargetDataComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2040737_1_73906
                if (circulationCollectionsRes != null) {
                    implementCalcCurOrParentTargetDataComReqDto.setLastCycleCalcModelId(circulationCollectionsRes.getLastCycleCalcModelId());//SimpleFieldAssign//sourceId:2040725_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setProcessCycleCalcModelId(circulationCollectionsRes.getProcessCycleCalcModelId());//SimpleFieldAssign//sourceId:2040726_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setSubCycleCalcModelId(circulationCollectionsRes.getSubCycleCalcModelId());//SimpleFieldAssign//sourceId:2040727_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setMidCycleCalcModelId(circulationCollectionsRes.getMidCycleCalcModelId());//SimpleFieldAssign//sourceId:2040728_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setParentCycleCalcModelId(circulationCollectionsRes.getParentCycleCalcModelId());//SimpleFieldAssign//sourceId:2040729_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setPreUpdateCycleId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2040730_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2040731_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:2040732_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:2040733_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setUpdateCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:2040734_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:2040735_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040736_1_73906
                }
                if (reqDto != null) {
                    implementCalcCurOrParentTargetDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040738_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040739_1_73906
                    implementCalcCurOrParentTargetDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040740_1_73906
                }

                /*D4执行MQ计算当前或祖先规划目标标准数据(公共)[10501]   */
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleId(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期ID不能为空", false);
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleStartTime(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期开始时间不能为空", false);
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleEndTime(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期结束时间不能为空", false);
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getUpdateCycleTypeCode(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期类型标识不能为空", false);
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getIsLastCycle(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-更新周期是否末级周期不能为空", false);
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getEvaluationTemplateId(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getSpaceId(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-创建于空间ID不能为空", false);
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getEventBatchUpdateCode(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-事务内数据更新批次标识不能为空", false);
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getCalcStartTime(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-计算开始时间不能为空", false);
                Assert.isNull(implementCalcCurOrParentTargetDataComReqDto.getTargetScoreUnit(), "D4执行MQ循环计算规划目标数据异常或修订场景(公共)-D4执行MQ计算当前或祖先规划目标标准数据(公共)-目标得分单位不能为空", false);
                implementCalcCurOrParentTargetDataComRespDto = implementCalcCurOrParentTargetDataCom(implementCalcCurOrParentTargetDataComReqDto)/*vcase invoke 同服务,同domain*/;


            }
//virtualUsage M4-执行【循环结束】  73907
            //ModelCode: circulationEnd
        }

        ImplementLoopCalcCyclesTargetDataComRespDto retData = new ImplementLoopCalcCyclesTargetDataComRespDto();


        return retData;
    }

    /**
     * D4执行MQ计算当前或兄弟内容异常场景(公共)[10504]
     * gen by moon at 3/6/2025, 10:14:40 PM
     */
    @Trace(operationName = "D4执行MQ计算当前或兄弟内容异常场景(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCalcCurOrBrothersTargetDataComRespDto implementCalcCurOrBrothersTargetDataCom(ImplementCalcCurOrBrothersTargetDataComReqDto reqDto) {


        if ((reqDto != null && reqDto.getDataCalcNormalAbnormal() != null && reqDto.getDataCalcNormalAbnormal().equals("ABNORMAL_SCENE"))) {
            //if(D4执行MQ计算当前或兄弟内容异常场景(公共).数据计算正常与异常场景 等于 异常场景)  73908

            QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = null;
            QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto = new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2040874_1_73910
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2040875_1_73910
            if (reqDto != null) {
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2040877_1_73910
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2040876_1_73910
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040879_1_73910
            }

            /*D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)[9935]   */
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getCycleStartTime(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-周期开始时间不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaluationTemplateId(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjEntityId(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTypeCode(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象类型编码不能为空", false);
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            ImplementLoopCalcCyclesTargetDataComRespDto implementLoopCalcCyclesTargetDataComRespDto = null;
            if (queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto != null) {
                ImplementLoopCalcCyclesTargetDataComReqDto implementLoopCalcCyclesTargetDataComReqDto = new ImplementLoopCalcCyclesTargetDataComReqDto();
                if (reqDto != null) {
                    implementLoopCalcCyclesTargetDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040880_1_73911
                    implementLoopCalcCyclesTargetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040881_1_73911
                    implementLoopCalcCyclesTargetDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040882_1_73911
                }
                if (queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto != null && queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList() != null && !CollectionUtil.isEmpty(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList())) {
                    implementLoopCalcCyclesTargetDataComReqDto.setTargetBelongCycleList(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList().stream().map(item -> BeanUtil.toBean(item, TargetBelongCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040883_1_73911
                }

                /*D4执行MQ循环计算规划目标数据异常或修订场景(公共)[10503]   */
                Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto.getEventBatchUpdateCode(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-事务内数据更新批次标识不能为空", false);
                Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto.getCalcStartTime(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-计算开始时间不能为空", false);
                Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto.getTargetScoreUnit(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-目标得分单位不能为空", false);
                implementLoopCalcCyclesTargetDataComRespDto = implementLoopCalcCyclesTargetDataCom(implementLoopCalcCyclesTargetDataComReqDto)/*vcase invoke 同服务,同domain*/;


            }
        } else if ((reqDto != null && reqDto.getDataCalcNormalAbnormal() != null && reqDto.getDataCalcNormalAbnormal().equals("REVISE_ABNORMAL_SCENE") && reqDto != null && reqDto.getParentEvaObjTargetCycleId() != null)) {
            //elseif((D4执行MQ计算当前或兄弟内容异常场景(公共).数据计算正常与异常场景 等于 修订异常场景 and D4执行MQ计算当前或兄弟内容异常场景(公共).上级被评对象目标周期标识 值不等于空 ))  73909

            QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 = null;
            QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1 = new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2040874_1_73912
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2040875_1_73912
            if (reqDto != null) {
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2040878_1_73912
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2040876_1_73912
                queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2040879_1_73912
            }

            /*D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)[9935]   */
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getCycleStartTime(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-周期开始时间不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaluationTemplateId(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaObjEntityId(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1.getEvaObjTypeCode(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D3查询目标归属周期（大于等于开始时间）-双排序列表(公共)-主树被评对象类型编码不能为空", false);
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            ImplementLoopCalcCyclesTargetDataComRespDto implementLoopCalcCyclesTargetDataComRespDto_1 = null;
            if (queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 != null) {
                ImplementLoopCalcCyclesTargetDataComReqDto implementLoopCalcCyclesTargetDataComReqDto_1 = new ImplementLoopCalcCyclesTargetDataComReqDto();
                if (reqDto != null) {
                    implementLoopCalcCyclesTargetDataComReqDto_1.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2040880_1_73913
                    implementLoopCalcCyclesTargetDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2040881_1_73913
                    implementLoopCalcCyclesTargetDataComReqDto_1.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2040882_1_73913
                }
                if (queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2 != null && queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList() != null && !CollectionUtil.isEmpty(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList())) {
                    implementLoopCalcCyclesTargetDataComReqDto_1.setTargetBelongCycleList(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto_2.getTargetBelongCycleList().stream().map(item -> BeanUtil.toBean(item, TargetBelongCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040883_1_73913
                }

                /*D4执行MQ循环计算规划目标数据异常或修订场景(公共)[10503]   */
                Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto_1.getEventBatchUpdateCode(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-事务内数据更新批次标识不能为空", false);
                Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto_1.getCalcStartTime(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-计算开始时间不能为空", false);
                Assert.isNull(implementLoopCalcCyclesTargetDataComReqDto_1.getTargetScoreUnit(), "D4执行MQ计算当前或兄弟内容异常场景(公共)-D4执行MQ循环计算规划目标数据异常或修订场景(公共)-目标得分单位不能为空", false);
                implementLoopCalcCyclesTargetDataComRespDto_1 = implementLoopCalcCyclesTargetDataCom(implementLoopCalcCyclesTargetDataComReqDto_1)/*vcase invoke 同服务,同domain*/;


            }
        }
        ImplementCalcCurOrBrothersTargetDataComRespDto retData = new ImplementCalcCurOrBrothersTargetDataComRespDto();


        return retData;
    }

    /**
     * D4执行MQ计算父级内容向上规划目标数据(公共)[10505]
     * gen by moon at 3/6/2025, 10:14:53 PM
     */
    @Trace(operationName = "D4执行MQ计算父级内容向上规划目标数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCalcParentTargetDataComRespDto implementCalcParentTargetDataCom(ImplementCalcParentTargetDataComReqDto reqDto) {


        //virtualUsage D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)  73914
        QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = null;
        QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto = new QueryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto();
        queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2041189_1_73914
        queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2041190_1_73914
        if (reqDto != null) {
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaObjTargetCycleCode(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2041192_1_73914
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2041191_1_73914
            queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2041193_1_73914
        }

        /*D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)[9935]   */
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTargetCycleCode(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-被评对象目标周期标识不能为空", false);
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getCycleStartTime(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-周期开始时间不能为空", false);
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaluationTemplateId(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-冗余评价模板ID不能为空", false);
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjEntityId(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-主树被评对象内容表主键ID不能为空", false);
        Assert.isNull(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto.getEvaObjTypeCode(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D3查询目标归属周期（大于等于开始时间或小于等于结束时间）-双排序列表(公共)-主树被评对象类型编码不能为空", false);
        queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto = fwAppEvaCalcClient.queryTargetBelongCycleByGeStartOrLeEndTimeSortListCom(queryTargetBelongCycleByGeStartOrLeEndTimeSortListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage M4执行目标归属周期【循环开始】  73915
        //ModelCode: circulationCollections
        for (com.wicket.okrapp.integration.dto.TargetBelongCycleDto circulationCollectionsRes : queryTargetBelongCycleByGeStartOrLeEndTimeSortListComRespDto.getTargetBelongCycleList()) {

//virtualUsage D4-1查标准数据详情(公共)  73916
            QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
            QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto = new QueryStandardDataDetailComReqDto();
            queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:2041208_1_73916
            if (circulationCollectionsRes != null) {
                queryStandardDataDetailComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2041206_1_73916
                queryStandardDataDetailComReqDto.setThemeContentId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2041207_1_73916
            }

            /*D4-1查标准数据详情(公共)[2695]   */
            Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4-1查标准数据详情(公共)-周期ID不能为空", false);
            Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空", false);
            Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空", false);
            queryStandardDataDetailComRespDto = standardDataService.queryStandardDataDetailCom(queryStandardDataDetailComReqDto)/*vcase invoke isSameApp*/;


            if ((queryStandardDataDetailComRespDto != null && queryStandardDataDetailComRespDto.getDataResultId() != null)) {
                //if(D4-1查标准数据详情(公共).数据结果ID  值不等于空 )  73917

                ImplementCalcCurAndParentTargetDataComRespDto implementCalcCurAndParentTargetDataComRespDto = null;
                ImplementCalcCurAndParentTargetDataComReqDto implementCalcCurAndParentTargetDataComReqDto = new ImplementCalcCurAndParentTargetDataComReqDto();
                implementCalcCurAndParentTargetDataComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2041169_1_73918
                implementCalcCurAndParentTargetDataComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:2041170_1_73918
                if (circulationCollectionsRes != null) {
                    implementCalcCurAndParentTargetDataComReqDto.setPreUpdateCycleId(circulationCollectionsRes.getPreviousCycleId());//SimpleFieldAssign//sourceId:2041163_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setUpdateCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:2041164_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setUpdateCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:2041165_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setUpdateCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:2041166_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setUpdateCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:2041167_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:2041168_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setEvaObjTargetCycleCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2041171_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType() != null ? String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()) : "");//SimpleFieldAssign//sourceId:2041172_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2041173_1_73918
                }
                if (reqDto != null) {
                    implementCalcCurAndParentTargetDataComReqDto.setEventBatchUpdateCode(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2041174_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2041175_1_73918
                    implementCalcCurAndParentTargetDataComReqDto.setTargetScoreUnit(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2041176_1_73918
                }

                /*D4执行MQ计算当前及祖先规划目标标准数据(公共)[10502]   */
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getUpdateCycleId(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期ID不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getUpdateCycleStartTime(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期开始时间不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getUpdateCycleEndTime(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期结束时间不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getUpdateCycleTypeCode(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期类型标识不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getIsLastCycle(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-更新周期是否末级周期不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEvaObjEntityId(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-主树被评对象内容表主键ID不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEvaObjTypeCode(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-主树被评对象类型编码不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEvaObjTargetCycleCode(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-被评对象目标周期标识不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getParentSubMidCycleType(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-父子中过程周期类型不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEvaluationTemplateId(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-冗余评价模板ID不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getEventBatchUpdateCode(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-事务内数据更新批次标识不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getCalcStartTime(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-计算开始时间不能为空", false);
                Assert.isNull(implementCalcCurAndParentTargetDataComReqDto.getTargetScoreUnit(), "D4执行MQ计算父级内容向上规划目标数据(公共)-D4执行MQ计算当前及祖先规划目标标准数据(公共)-目标得分单位不能为空", false);
                implementCalcCurAndParentTargetDataComRespDto = implementCalcCurAndParentTargetDataCom(implementCalcCurAndParentTargetDataComReqDto)/*vcase invoke 同服务,同domain*/;


            }
//virtualUsage M4-执行【循环结束】  73919
            //ModelCode: circulationEnd
        }

        ImplementCalcParentTargetDataComRespDto retData = new ImplementCalcParentTargetDataComRespDto();


        return retData;
    }

    /**
     * D4新增规划目标MQ队列数据(公共)[10491]
     * gen by moon at 3/10/2025, 8:12:31 PM
     */
    @Trace(operationName = "D4新增规划目标MQ队列数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddPlanTargetMqQueueComRespDto addPlanTargetMqQueueCom(AddPlanTargetMqQueueComReqDto reqDto) {


        //步骤0: D2新增MQ队列数据(业务原子) - addMessageQueueDataBusCom
        AddMessageQueueDataBusComRespDto addMessageQueueDataBusComRespDto = null;
        AddMessageQueueDataBusComReqDto addMessageQueueDataBusComReqDto = new AddMessageQueueDataBusComReqDto();
        addMessageQueueDataBusComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2039656_1
        addMessageQueueDataBusComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2039658_1
        addMessageQueueDataBusComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2039660_1
        addMessageQueueDataBusComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2039662_1
        addMessageQueueDataBusComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2039664_1
        addMessageQueueDataBusComReqDto.setCustomField6("isLastCycle");//CUSTOM_CONVENTION//sourceId:2039666_1
        addMessageQueueDataBusComReqDto.setCustomField7("parentSubMidCycleType");//CUSTOM_CONVENTION//sourceId:2039668_1
        addMessageQueueDataBusComReqDto.setCustomField8("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:2039670_1
        addMessageQueueDataBusComReqDto.setCustomField9("parentEvaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2039672_1
        addMessageQueueDataBusComReqDto.setCustomField10("belongToContentId");//CUSTOM_CONVENTION//sourceId:2039674_1
        addMessageQueueDataBusComReqDto.setCustomField11("evaObjEntityId");//CUSTOM_CONVENTION//sourceId:2039676_1
        addMessageQueueDataBusComReqDto.setCustomField12("evaObjTypeCode");//CUSTOM_CONVENTION//sourceId:2039678_1
        addMessageQueueDataBusComReqDto.setCustomField13("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2039680_1
        addMessageQueueDataBusComReqDto.setCustomField14("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2039682_1
        addMessageQueueDataBusComReqDto.setCustomField15("calcStartTime");//CUSTOM_CONVENTION//sourceId:2039684_1
        addMessageQueueDataBusComReqDto.setCustomField16("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:2039686_1
        addMessageQueueDataBusComReqDto.setCustomField17("dataCalcNormalAbnormal");//CUSTOM_CONVENTION//sourceId:2039688_1
        addMessageQueueDataBusComReqDto.setCustomField18("operationInductionId");//CUSTOM_CONVENTION//sourceId:2042105_1
        addMessageQueueDataBusComReqDto.setCustomField19("spaceId");//CUSTOM_CONVENTION//sourceId:2042107_1
        addMessageQueueDataBusComReqDto.setCustomField20("appId");//CUSTOM_CONVENTION//sourceId:2042109_1
        if (reqDto != null) {
            addMessageQueueDataBusComReqDto.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039716_1
            addMessageQueueDataBusComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039717_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue1(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2039657_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue2(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2039659_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2039661_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2039663_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2039665_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue6(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2039667_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue7(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2039669_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue8(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2039671_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue9(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2039673_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue10(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2039675_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue11(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2039677_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue12(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2039679_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue13(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2039681_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue14(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2039683_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue15(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2039685_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue16(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2039687_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue17(reqDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2039689_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue18(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:2042106_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue19(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2042108_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue20(reqDto.getAppId());//SimpleFieldAssign//sourceId:2042110_1
        }

        /*D2新增MQ队列数据(业务原子)[10490]   */
        Assert.isNull(addMessageQueueDataBusComReqDto.getMqQueueName(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列名称不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getMqPrimaryId(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列唯一主键ID不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField1(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段1不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField2(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段2不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue2(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值2不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField3(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段3不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue3(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值3不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField4(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段4不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue4(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值4不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField5(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段5不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue5(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值5不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField6(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段6不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue6(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值6不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField7(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段7不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue7(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值7不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField8(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段8不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue8(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值8不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField9(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段9不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField10(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段10不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue10(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值10不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField11(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段11不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue11(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值11不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField12(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段12不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue12(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值12不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField13(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段13不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue13(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值13不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField14(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段14不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue14(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值14不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField15(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段15不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue15(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值15不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField16(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段16不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue16(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值16不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField17(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段17不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue17(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值17不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField18(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段18不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue18(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值18不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField19(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段19不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue19(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值19不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField20(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段20不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue20(), "D4新增规划目标MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值20不能为空", false);
        addMessageQueueDataBusComRespDto = fwCompBusinessAtomClient.addMessageQueueDataBusCom(addMessageQueueDataBusComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        AddPlanTargetMqQueueComRespDto retData = new AddPlanTargetMqQueueComRespDto();


        return retData;
    }

    /**
     * D4新增规划财务MQ队列数据(公共)[10492]
     * gen by moon at 3/10/2025, 8:12:39 PM
     */
    @Trace(operationName = "D4新增规划财务MQ队列数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddPlanFinanceMqQueueComRespDto addPlanFinanceMqQueueCom(AddPlanFinanceMqQueueComReqDto reqDto) {


        //步骤0: D2新增MQ队列数据(业务原子) - addMessageQueueDataBusCom
        AddMessageQueueDataBusComRespDto addMessageQueueDataBusComRespDto = null;
        AddMessageQueueDataBusComReqDto addMessageQueueDataBusComReqDto = new AddMessageQueueDataBusComReqDto();
        addMessageQueueDataBusComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2039752_1
        addMessageQueueDataBusComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2039754_1
        addMessageQueueDataBusComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2039756_1
        addMessageQueueDataBusComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2039758_1
        addMessageQueueDataBusComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2039760_1
        addMessageQueueDataBusComReqDto.setCustomField6("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2039762_1
        addMessageQueueDataBusComReqDto.setCustomField7("accountContentCode");//CUSTOM_CONVENTION//sourceId:2039764_1
        addMessageQueueDataBusComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:2039766_1
        addMessageQueueDataBusComReqDto.setCustomField9("cycleMode");//CUSTOM_CONVENTION//sourceId:2039768_1
        addMessageQueueDataBusComReqDto.setCustomField10(CommonFunctionHelper.getSessionUrl());//ACCESS_ADDRESS//sourceId:2039770_1
        addMessageQueueDataBusComReqDto.setCustomField11("operationInductionId");//CUSTOM_CONVENTION//sourceId:2039772_1
        addMessageQueueDataBusComReqDto.setCustomField12("spaceId");//CUSTOM_CONVENTION//sourceId:2039774_1
        addMessageQueueDataBusComReqDto.setCustomField13("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2039776_1
        addMessageQueueDataBusComReqDto.setCustomField14("calcStartTime");//CUSTOM_CONVENTION//sourceId:2039778_1
        addMessageQueueDataBusComReqDto.setCustomField15("unit");//CUSTOM_CONVENTION//sourceId:2039780_1
        addMessageQueueDataBusComReqDto.setCustomField16("appId");//CUSTOM_CONVENTION//sourceId:2042101_1
        if (reqDto != null) {
            addMessageQueueDataBusComReqDto.setMqQueueName(reqDto.getMqQueueName());//SimpleFieldAssign//sourceId:2039812_1
            addMessageQueueDataBusComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2039813_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue1(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2039753_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue2(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2039755_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2039757_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2039759_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2039761_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue6(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2039763_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue7(reqDto.getAccountContentCode());//SimpleFieldAssign//sourceId:2039765_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue8(reqDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:2039767_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue9(reqDto.getCycleMode());//SimpleFieldAssign//sourceId:2039769_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue10(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2039771_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue11(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:2039773_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue12(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2039775_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue13(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2039777_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue14(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2039779_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue15(reqDto.getUnit());//SimpleFieldAssign//sourceId:2039781_1
            addMessageQueueDataBusComReqDto.setCustomFieldValue16(reqDto.getAppId());//SimpleFieldAssign//sourceId:2042102_1
        }

        /*D2新增MQ队列数据(业务原子)[10490]   */
        Assert.isNull(addMessageQueueDataBusComReqDto.getMqQueueName(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列名称不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getMqPrimaryId(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-MQ队列唯一主键ID不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField1(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段1不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField2(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段2不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue2(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值2不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField3(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段3不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue3(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值3不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField4(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段4不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue4(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值4不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField5(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段5不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue5(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值5不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField6(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段6不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue6(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值6不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField7(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段7不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue7(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值7不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField8(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段8不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue8(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值8不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField9(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段9不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue9(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值9不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField10(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段10不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue10(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值10不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField11(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段11不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue11(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值11不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField12(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段12不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue12(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值12不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField13(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段13不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue13(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值13不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField14(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段14不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue14(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值14不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField15(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段15不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue15(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值15不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomField16(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段16不能为空", false);
        Assert.isNull(addMessageQueueDataBusComReqDto.getCustomFieldValue16(), "D4新增规划财务MQ队列数据(公共)-D2新增MQ队列数据(业务原子)-自定义字段值16不能为空", false);
        addMessageQueueDataBusComRespDto = fwCompBusinessAtomClient.addMessageQueueDataBusCom(addMessageQueueDataBusComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        AddPlanFinanceMqQueueComRespDto retData = new AddPlanFinanceMqQueueComRespDto();


        return retData;
    }

    /**
     * D4查询规划目标MQ队列数据列表(公共)[10493]
     * gen by moon at 3/10/2025, 8:12:45 PM
     */
    @Trace(operationName = "D4查询规划目标MQ队列数据列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPlanTargetMqQueueListComRespDto queryPlanTargetMqQueueListCom(QueryPlanTargetMqQueueListComReqDto reqDto) {


        QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto_1 = null;
//步骤0: D2查询MQ队列数据列表(业务原子) - queryMessageQueueDataListCom
        QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto = null;
        QueryMessageQueueDataListComReqDto queryMessageQueueDataListComReqDto = new QueryMessageQueueDataListComReqDto();
        queryMessageQueueDataListComReqDto.setMqQueueName("PLAN_TARGET_CALC_MQ_QUEUE");//sourceId:2040160_1
        queryMessageQueueDataListComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2040040_1
        queryMessageQueueDataListComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2040041_1
        queryMessageQueueDataListComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2040042_1
        queryMessageQueueDataListComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2040043_1
        queryMessageQueueDataListComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2040044_1
        queryMessageQueueDataListComReqDto.setCustomField6("isLastCycle");//CUSTOM_CONVENTION//sourceId:2040045_1
        queryMessageQueueDataListComReqDto.setCustomField7("parentSubMidCycleType");//CUSTOM_CONVENTION//sourceId:2040046_1
        queryMessageQueueDataListComReqDto.setCustomField8("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:2040047_1
        queryMessageQueueDataListComReqDto.setCustomField9("parentEvaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2040048_1
        queryMessageQueueDataListComReqDto.setCustomField10("belongToContentId");//CUSTOM_CONVENTION//sourceId:2040049_1
        queryMessageQueueDataListComReqDto.setCustomField11("evaObjEntityId");//CUSTOM_CONVENTION//sourceId:2040050_1
        queryMessageQueueDataListComReqDto.setCustomField12("evaObjTypeCode");//CUSTOM_CONVENTION//sourceId:2040051_1
        queryMessageQueueDataListComReqDto.setCustomField13("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2040052_1
        queryMessageQueueDataListComReqDto.setCustomField14("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2040053_1
        queryMessageQueueDataListComReqDto.setCustomField15("calcStartTime");//CUSTOM_CONVENTION//sourceId:2040054_1
        queryMessageQueueDataListComReqDto.setCustomField16("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:2040055_1
        queryMessageQueueDataListComReqDto.setCustomField17("dataCalcNormalAbnormal");//CUSTOM_CONVENTION//sourceId:2040056_1
        queryMessageQueueDataListComReqDto.setCustomField18("operationInductionId");//CUSTOM_CONVENTION//sourceId:2042117_1
        queryMessageQueueDataListComReqDto.setCustomField19("spaceId");//CUSTOM_CONVENTION//sourceId:2042118_1
        queryMessageQueueDataListComReqDto.setCustomField20("appId");//CUSTOM_CONVENTION//sourceId:2042119_1
        if (reqDto != null) {
            queryMessageQueueDataListComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040161_1
        }

        /*D2查询MQ队列数据列表(业务原子)[10495]   */
        Assert.isNull(queryMessageQueueDataListComReqDto.getMqQueueName(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列名称不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getMqPrimaryId(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列唯一主键ID不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField1(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段1不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField2(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段2不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField3(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段3不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField4(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段4不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField5(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段5不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField6(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段6不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField7(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段7不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField8(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段8不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField9(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段9不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField10(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段10不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField11(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段11不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField12(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段12不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField13(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段13不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField14(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段14不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField15(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段15不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField16(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段16不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField17(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段17不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField18(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段18不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField19(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段19不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField20(), "D4查询规划目标MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段20不能为空", false);
        queryMessageQueueDataListComRespDto = fwCompBusinessAtomClient.queryMessageQueueDataListCom(queryMessageQueueDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryMessageQueueDataListComRespDto_1 = queryMessageQueueDataListComRespDto;

        QueryPlanTargetMqQueueListComRespDto retData = new QueryPlanTargetMqQueueListComRespDto();
        if (queryMessageQueueDataListComRespDto_1 != null) {
            retData.setMqQueueName(queryMessageQueueDataListComRespDto_1.getMqQueueName());//SimpleFieldAssign//sourceId:2040091_1
            retData.setMqPrimaryId(queryMessageQueueDataListComRespDto_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040092_1
            retData.setMqQueueMinimum(queryMessageQueueDataListComRespDto_1.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2040093_1
            retData.setFieldDataList(//objList-to-objLists
                    queryMessageQueueDataListComRespDto_1.getFieldDataList().stream().map(item -> {
                        FieldDataDto elm = new FieldDataDto();
                        if (item != null) {
                            elm.setPreUpdateCycleId(item.getCustomField1());//SimpleFieldAssign//sourceId:431904_2
                            elm.setUpdateCycleId(item.getCustomField2());//SimpleFieldAssign//sourceId:431905_2
                            elm.setUpdateCycleStartTime(item.getCustomField3());//SimpleFieldAssign//sourceId:431906_2
                            elm.setUpdateCycleEndTime(item.getCustomField4());//SimpleFieldAssign//sourceId:431907_2
                            elm.setUpdateCycleTypeCode(item.getCustomField5());//SimpleFieldAssign//sourceId:431908_2
                            elm.setIsLastCycle(item.getCustomField6());//SimpleFieldAssign//sourceId:431909_2
                            elm.setParentSubMidCycleType(item.getCustomField7());//SimpleFieldAssign//sourceId:431910_2
                            elm.setEvaObjTargetCycleCode(item.getCustomField8());//SimpleFieldAssign//sourceId:431911_2
                            elm.setParentEvaObjTargetCycleId(item.getCustomField9());//SimpleFieldAssign//sourceId:431912_2
                            elm.setBelongToContentId(item.getCustomField10());//SimpleFieldAssign//sourceId:431913_2
                            elm.setEvaObjEntityId(item.getCustomField11());//SimpleFieldAssign//sourceId:431914_2
                            elm.setEvaObjTypeCode(item.getCustomField12());//SimpleFieldAssign//sourceId:431915_2
                            elm.setEvaluationTemplateId(item.getCustomField13());//SimpleFieldAssign//sourceId:431916_2
                            elm.setEventBatchUpdateCode(item.getCustomField14());//SimpleFieldAssign//sourceId:431917_2
                            elm.setCalcStartTime(item.getCustomField15());//SimpleFieldAssign//sourceId:431918_2
                            elm.setTargetScoreUnit(item.getCustomField16());//SimpleFieldAssign//sourceId:431919_2
                            elm.setDataCalcNormalAbnormal(item.getCustomField17());//SimpleFieldAssign//sourceId:431920_2
                            elm.setOperationInductionId(item.getCustomField18());//SimpleFieldAssign//sourceId:432615_2
                            elm.setSpaceId(item.getCustomField19());//SimpleFieldAssign//sourceId:432616_2
                            elm.setAppId(item.getCustomField20());//SimpleFieldAssign//sourceId:432617_2
                            elm.setMqDataPosition(item.getMqDataPosition());//SimpleFieldAssign//sourceId:432603_2
                        }
                        return elm;
                    }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040094_1
        }


        return retData;
    }

    /**
     * D4查询规划财务MQ队列数据列表(公共)[10494]
     * gen by moon at 3/10/2025, 8:12:48 PM
     */
    @Trace(operationName = "D4查询规划财务MQ队列数据列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPlanFinanceMqQueueListComRespDto queryPlanFinanceMqQueueListCom(QueryPlanFinanceMqQueueListComReqDto reqDto) {


        QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto_1 = null;
//步骤0: D2查询MQ队列数据列表(业务原子) - queryMessageQueueDataListCom
        QueryMessageQueueDataListComRespDto queryMessageQueueDataListComRespDto = null;
        QueryMessageQueueDataListComReqDto queryMessageQueueDataListComReqDto = new QueryMessageQueueDataListComReqDto();
        queryMessageQueueDataListComReqDto.setMqQueueName("FINANCIAL_CALC_MQ_QUEUE");//sourceId:2040157_1
        queryMessageQueueDataListComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2040095_1
        queryMessageQueueDataListComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:2040096_1
        queryMessageQueueDataListComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2040097_1
        queryMessageQueueDataListComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2040098_1
        queryMessageQueueDataListComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2040099_1
        queryMessageQueueDataListComReqDto.setCustomField6("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2040100_1
        queryMessageQueueDataListComReqDto.setCustomField7("accountContentCode");//CUSTOM_CONVENTION//sourceId:2040101_1
        queryMessageQueueDataListComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:2040102_1
        queryMessageQueueDataListComReqDto.setCustomField9("cycleMode");//CUSTOM_CONVENTION//sourceId:2040103_1
        queryMessageQueueDataListComReqDto.setCustomField10("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2040104_1
        queryMessageQueueDataListComReqDto.setCustomField11("operationInductionId");//CUSTOM_CONVENTION//sourceId:2040105_1
        queryMessageQueueDataListComReqDto.setCustomField12("spaceId");//CUSTOM_CONVENTION//sourceId:2040106_1
        queryMessageQueueDataListComReqDto.setCustomField13("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2040107_1
        queryMessageQueueDataListComReqDto.setCustomField14("calcStartTime");//CUSTOM_CONVENTION//sourceId:2040108_1
        queryMessageQueueDataListComReqDto.setCustomField15("unit");//CUSTOM_CONVENTION//sourceId:2040109_1
        queryMessageQueueDataListComReqDto.setCustomField16("appId");//CUSTOM_CONVENTION//sourceId:2042120_1
        if (reqDto != null) {
            queryMessageQueueDataListComReqDto.setMqPrimaryId(reqDto.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040158_1
        }

        /*D2查询MQ队列数据列表(业务原子)[10495]   */
        Assert.isNull(queryMessageQueueDataListComReqDto.getMqQueueName(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列名称不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getMqPrimaryId(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-MQ队列唯一主键ID不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField1(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段1不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField2(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段2不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField3(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段3不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField4(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段4不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField5(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段5不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField6(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段6不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField7(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段7不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField8(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段8不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField9(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段9不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField10(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段10不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField11(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段11不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField12(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段12不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField13(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段13不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField14(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段14不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField15(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段15不能为空", false);
        Assert.isNull(queryMessageQueueDataListComReqDto.getCustomField16(), "D4查询规划财务MQ队列数据列表(公共)-D2查询MQ队列数据列表(业务原子)-自定义字段16不能为空", false);
        queryMessageQueueDataListComRespDto = fwCompBusinessAtomClient.queryMessageQueueDataListCom(queryMessageQueueDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        queryMessageQueueDataListComRespDto_1 = queryMessageQueueDataListComRespDto;

        QueryPlanFinanceMqQueueListComRespDto retData = new QueryPlanFinanceMqQueueListComRespDto();
        if (queryMessageQueueDataListComRespDto_1 != null) {
            retData.setMqQueueName(queryMessageQueueDataListComRespDto_1.getMqQueueName());//SimpleFieldAssign//sourceId:2040129_1
            retData.setMqPrimaryId(queryMessageQueueDataListComRespDto_1.getMqPrimaryId());//SimpleFieldAssign//sourceId:2040130_1
            retData.setMqQueueMinimum(queryMessageQueueDataListComRespDto_1.getMqQueueMinimum());//SimpleFieldAssign//sourceId:2040131_1
            retData.setFieldDataList(//objList-to-objLists
                    queryMessageQueueDataListComRespDto_1.getFieldDataList().stream().map(item -> {
                        FieldDataDto elm = new FieldDataDto();
                        if (item != null) {
                            elm.setPreUpdateCycleId(item.getCustomField1());//SimpleFieldAssign//sourceId:431964_2
                            elm.setUpdateCycleId(item.getCustomField2());//SimpleFieldAssign//sourceId:431965_2
                            elm.setUpdateCycleStartTime(item.getCustomField3());//SimpleFieldAssign//sourceId:431966_2
                            elm.setUpdateCycleEndTime(item.getCustomField4());//SimpleFieldAssign//sourceId:431967_2
                            elm.setUpdateCycleTypeCode(item.getCustomField5());//SimpleFieldAssign//sourceId:431968_2
                            elm.setEvaObjTargetCycleId(item.getCustomField6());//SimpleFieldAssign//sourceId:431969_2
                            elm.setAccountContentCode(item.getCustomField7());//SimpleFieldAssign//sourceId:431970_2
                            elm.setIsOpenFundsArrival(item.getCustomField8());//SimpleFieldAssign//sourceId:431971_2
                            elm.setCycleMode(item.getCustomField9());//SimpleFieldAssign//sourceId:431972_2
                            elm.setEvaluationTemplateId(item.getCustomField10());//SimpleFieldAssign//sourceId:431973_2
                            elm.setOperationInductionId(item.getCustomField11());//SimpleFieldAssign//sourceId:431974_2
                            elm.setSpaceId(item.getCustomField12());//SimpleFieldAssign//sourceId:431975_2
                            elm.setEventBatchUpdateCode(item.getCustomField13());//SimpleFieldAssign//sourceId:431976_2
                            elm.setCalcStartTime(item.getCustomField14());//SimpleFieldAssign//sourceId:431977_2
                            elm.setUnit(item.getCustomField15());//SimpleFieldAssign//sourceId:431978_2
                            elm.setAppId(item.getCustomField16());//SimpleFieldAssign//sourceId:432622_2
                            elm.setMqDataPosition(item.getMqDataPosition());//SimpleFieldAssign//sourceId:432606_2
                        }
                        return elm;
                    }).collect(Collectors.toList()));//objList-to-objLists//sourceId:2040132_1
        }


        return retData;
    }

    /**
     * D4新增规划目标MQ-Redis队列数据(公共)[10524]
     * gen by moon at 4/20/2025, 4:29:37 PM
     */
    @Trace(operationName = "D4新增规划目标MQ-Redis队列数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddPlanTargetMqRedisQueueComRespDto addPlanTargetMqRedisQueueCom(AddPlanTargetMqRedisQueueComReqDto reqDto) {


        //步骤0: M4-接收字段入参（计算使用） - addAcceptField
        //ModelCode: receptionService
        AddAcceptFieldRespDto receptionServiceRes = null;
        AddAcceptFieldReqDto receptionServiceReq = new AddAcceptFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2045804_1
            receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2045809_1
            receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2045810_1
        }

        /*M4-接收字段入参（计算使用）[6392]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D4新增规划目标MQ-Redis队列数据(公共)-M4-接收字段入参（计算使用）-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(), "D4新增规划目标MQ-Redis队列数据(公共)-M4-接收字段入参（计算使用）-更新周期开始时间不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(), "D4新增规划目标MQ-Redis队列数据(公共)-M4-接收字段入参（计算使用）-更新周期结束时间不能为空", false);
        receptionServiceRes = nbEvaCalc.addAcceptField(receptionServiceReq);


//步骤1: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto = new ImplementTimeFormatConversionComReqDto();
        if (reqDto != null) {
            implementTimeFormatConversionComReqDto.setComTxtField(reqDto.getUpdateCycleStartTime() != null ? String.valueOf(reqDto.getUpdateCycleStartTime()) : "");//SimpleFieldAssign//sourceId:2045811_1
        }

        /*D2更新周期开始时间[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(), "D4新增规划目标MQ-Redis队列数据(公共)-D2更新周期开始时间-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤2: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1 = new ImplementTimeFormatConversionComReqDto();
        if (reqDto != null) {
            implementTimeFormatConversionComReqDto_1.setComTxtField(reqDto.getUpdateCycleEndTime() != null ? String.valueOf(reqDto.getUpdateCycleEndTime()) : "");//SimpleFieldAssign//sourceId:2045813_1
        }

        /*D2更新周期结束时间[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(), "D4新增规划目标MQ-Redis队列数据(公共)-D2更新周期结束时间-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto_2 = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤3: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
        AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
        AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
        addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:2045919_1
        addRedisBusinessDataSetComReqDto.setBusinessDataObject("PLAN_TARGET_CALC_MQ_QUEUE");//sourceId:2045816_1
        addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:2045918_1
        addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:2045815_1
        addRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:2045817_1
        addRedisBusinessDataSetComReqDto.setCustomField2("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2045819_1
        addRedisBusinessDataSetComReqDto.setCustomField3("updateCycleId");//CUSTOM_CONVENTION//sourceId:2045821_1
        addRedisBusinessDataSetComReqDto.setCustomField4("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2045823_1
        addRedisBusinessDataSetComReqDto.setCustomField5("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2045825_1
        addRedisBusinessDataSetComReqDto.setCustomField6("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2045827_1
        addRedisBusinessDataSetComReqDto.setCustomField7("isLastCycle");//CUSTOM_CONVENTION//sourceId:2045829_1
        addRedisBusinessDataSetComReqDto.setCustomField8("parentSubMidCycleType");//CUSTOM_CONVENTION//sourceId:2045831_1
        addRedisBusinessDataSetComReqDto.setCustomField9("evaObjTargetCycleCode");//CUSTOM_CONVENTION//sourceId:2045833_1
        addRedisBusinessDataSetComReqDto.setCustomField10("parentEvaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2045835_1
        addRedisBusinessDataSetComReqDto.setCustomField11("belongToContentId");//CUSTOM_CONVENTION//sourceId:2045837_1
        addRedisBusinessDataSetComReqDto.setCustomField12("evaObjEntityId");//CUSTOM_CONVENTION//sourceId:2045839_1
        addRedisBusinessDataSetComReqDto.setCustomField13("evaObjTypeCode");//CUSTOM_CONVENTION//sourceId:2045841_1
        addRedisBusinessDataSetComReqDto.setCustomField14("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2045843_1
        addRedisBusinessDataSetComReqDto.setCustomField15("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2045845_1
        addRedisBusinessDataSetComReqDto.setCustomField16("calcStartTime");//CUSTOM_CONVENTION//sourceId:2045847_1
        addRedisBusinessDataSetComReqDto.setCustomField17("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:2045849_1
        addRedisBusinessDataSetComReqDto.setCustomField18("dataCalcNormalAbnormal");//CUSTOM_CONVENTION//sourceId:2045851_1
        addRedisBusinessDataSetComReqDto.setCustomField19("operationInductionId");//CUSTOM_CONVENTION//sourceId:2045853_1
        addRedisBusinessDataSetComReqDto.setCustomField20("spaceId");//CUSTOM_CONVENTION//sourceId:2045855_1
        addRedisBusinessDataSetComReqDto.setCustomField21("appId");//CUSTOM_CONVENTION//sourceId:2045857_1
        if (reqDto != null) {
            addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2045917_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getQueueNum());//SimpleFieldAssign//sourceId:2045818_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2045820_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2045822_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleStartTime() != null ? String.valueOf(reqDto.getUpdateCycleStartTime()) : "");//SimpleFieldAssign//sourceId:2045824_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleEndTime() != null ? String.valueOf(reqDto.getUpdateCycleEndTime()) : "");//SimpleFieldAssign//sourceId:2045826_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue6(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2045828_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue7(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:2045830_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue8(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:2045832_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue9(reqDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2045834_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue10(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2045836_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue11(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:2045838_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue12(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2045840_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue13(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2045842_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue14(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2045844_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue15(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2045846_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue16(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2045848_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue17(reqDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:2045850_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue18(reqDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2045852_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue19(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:2045854_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue20(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2045856_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue21(reqDto.getAppId());//SimpleFieldAssign//sourceId:2045858_1
        }

        /*D2-新增redis业务数据对象（业务原子）[8399]   */
        Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getDataObjectBatchCode(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-数据对象批次标识不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-是否删除redis历史数据不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段1不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段2不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段3不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值3不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段4不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值4不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段5不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值5不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段6不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值6不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段7不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值7不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段8不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值8不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段9不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值9不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段10不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField11(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段11不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值11不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField12(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段12不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue12(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值12不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField13(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段13不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue13(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值13不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField14(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段14不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue14(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值14不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField15(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段15不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue15(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值15不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField16(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段16不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue16(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值16不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField17(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段17不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue17(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值17不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField18(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段18不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue18(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值18不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField19(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段19不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue19(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值19不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField20(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段20不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue20(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值20不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField21(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段21不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue21(), "D4新增规划目标MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值21不能为空", false);
        addRedisBusinessDataSetComRespDto = fwCompBusinessAtomClient.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        AddPlanTargetMqRedisQueueComRespDto retData = new AddPlanTargetMqRedisQueueComRespDto();


        return retData;
    }

    /**
     * D4新增规划财务MQ-Redis队列数据(公共)[10525]
     * gen by moon at 4/20/2025, 4:29:55 PM
     */
    @Trace(operationName = "D4新增规划财务MQ-Redis队列数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddFinancialPlannMqRedisQueueComRespDto addFinancialPlannMqRedisQueueCom(AddFinancialPlannMqRedisQueueComReqDto reqDto) {


        //步骤0: M4-执行接收字段（特殊方法） - implementReceiveField
        //ModelCode: receptionService
        ImplementReceiveFieldRespDto receptionServiceRes = null;
        ImplementReceiveFieldReqDto receptionServiceReq = new ImplementReceiveFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2046488_1
            receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:2046489_1
            receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:2046490_1
        }

        /*M4-执行接收字段（特殊方法）[2950]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D4新增规划财务MQ-Redis队列数据(公共)-M4-执行接收字段（特殊方法）-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(), "D4新增规划财务MQ-Redis队列数据(公共)-M4-执行接收字段（特殊方法）-更新周期开始时间不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(), "D4新增规划财务MQ-Redis队列数据(公共)-M4-执行接收字段（特殊方法）-更新周期结束时间不能为空", false);
        receptionServiceRes = nbEvaCalc.implementReceiveField(receptionServiceReq);


//步骤1: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto = new ImplementTimeFormatConversionComReqDto();
        if (reqDto != null) {
            implementTimeFormatConversionComReqDto.setComTxtField(reqDto.getUpdateCycleStartTime() != null ? String.valueOf(reqDto.getUpdateCycleStartTime()) : "");//SimpleFieldAssign//sourceId:2046365_1
        }

        /*D2执行时间格式转换(公共)[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(), "D4新增规划财务MQ-Redis队列数据(公共)-D2执行时间格式转换(公共)-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤2: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1 = new ImplementTimeFormatConversionComReqDto();
        if (reqDto != null) {
            implementTimeFormatConversionComReqDto_1.setComTxtField(reqDto.getUpdateCycleEndTime() != null ? String.valueOf(reqDto.getUpdateCycleEndTime()) : "");//SimpleFieldAssign//sourceId:2046367_1
        }

        /*D2执行时间格式转换(公共)[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(), "D4新增规划财务MQ-Redis队列数据(公共)-D2执行时间格式转换(公共)-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto_2 = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


//步骤3: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
        AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
        AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
        addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:2046473_1
        addRedisBusinessDataSetComReqDto.setBusinessDataObject("FINANCIAL_CALC_MQ_QUEUE");//sourceId:2046370_1
        addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:2046472_1
        addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:2046369_1
        addRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:2046371_1
        addRedisBusinessDataSetComReqDto.setCustomField2("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:2046373_1
        addRedisBusinessDataSetComReqDto.setCustomField3("updateCycleId");//CUSTOM_CONVENTION//sourceId:2046375_1
        addRedisBusinessDataSetComReqDto.setCustomField4("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:2046377_1
        addRedisBusinessDataSetComReqDto.setCustomField5("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:2046379_1
        addRedisBusinessDataSetComReqDto.setCustomField6("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:2046381_1
        addRedisBusinessDataSetComReqDto.setCustomField7("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:2046383_1
        addRedisBusinessDataSetComReqDto.setCustomField8("accountContentCode");//CUSTOM_CONVENTION//sourceId:2046385_1
        addRedisBusinessDataSetComReqDto.setCustomField9("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:2046387_1
        addRedisBusinessDataSetComReqDto.setCustomField10("cycleMode");//CUSTOM_CONVENTION//sourceId:2046389_1
        addRedisBusinessDataSetComReqDto.setCustomField11("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:2046391_1
        addRedisBusinessDataSetComReqDto.setCustomField12("operationInductionId");//CUSTOM_CONVENTION//sourceId:2046393_1
        addRedisBusinessDataSetComReqDto.setCustomField13("spaceId");//CUSTOM_CONVENTION//sourceId:2046395_1
        addRedisBusinessDataSetComReqDto.setCustomField14("eventBatchUpdateCode");//CUSTOM_CONVENTION//sourceId:2046397_1
        addRedisBusinessDataSetComReqDto.setCustomField15("calcStartTime");//CUSTOM_CONVENTION//sourceId:2046399_1
        addRedisBusinessDataSetComReqDto.setCustomField16("unit");//CUSTOM_CONVENTION//sourceId:2046401_1
        addRedisBusinessDataSetComReqDto.setCustomField17("appId");//CUSTOM_CONVENTION//sourceId:2046403_1
        if (reqDto != null) {
            addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2046471_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getQueueNum());//SimpleFieldAssign//sourceId:2046372_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:2046374_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:2046376_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue4(reqDto.getUpdateCycleStartTime() != null ? String.valueOf(reqDto.getUpdateCycleStartTime()) : "");//SimpleFieldAssign//sourceId:2046378_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue5(reqDto.getUpdateCycleEndTime() != null ? String.valueOf(reqDto.getUpdateCycleEndTime()) : "");//SimpleFieldAssign//sourceId:2046380_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue6(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:2046382_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue7(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2046384_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue8(reqDto.getAccountContentCode());//SimpleFieldAssign//sourceId:2046386_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue9(reqDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:2046388_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue10(reqDto.getCycleMode());//SimpleFieldAssign//sourceId:2046390_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue11(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2046392_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue12(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:2046394_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue13(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2046396_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue14(reqDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:2046398_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue15(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:2046400_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue16(reqDto.getUnit());//SimpleFieldAssign//sourceId:2046402_1
            addRedisBusinessDataSetComReqDto.setCustomFieldValue17(reqDto.getAppId());//SimpleFieldAssign//sourceId:2046404_1
        }

        /*D2-新增redis业务数据对象（业务原子）[8399]   */
        Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段1不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段2不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段3不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值3不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值6不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值7不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值8不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值9不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue10(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值10不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值11不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue12(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值12不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue13(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值13不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue14(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值14不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue15(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值15不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue16(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值16不能为空", false);
        Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue17(), "D4新增规划财务MQ-Redis队列数据(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值17不能为空", false);
        addRedisBusinessDataSetComRespDto = fwCompBusinessAtomClient.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        AddFinancialPlannMqRedisQueueComRespDto retData = new AddFinancialPlannMqRedisQueueComRespDto();


        return retData;
    }
    //
}
